1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2020 The Khronos Group Inc.
6 * Copyright (c) 2020 Valve Corporation.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief Test frag shader side effects are not removed by optimizations.
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktRasterizationFragShaderSideEffectsTests.hpp"
26 #include "vktTestCase.hpp"
27
28 #include "vkQueryUtil.hpp"
29 #include "vkObjUtil.hpp"
30 #include "vkBuilderUtil.hpp"
31 #include "vkImageWithMemory.hpp"
32 #include "vkBufferWithMemory.hpp"
33 #include "vkTypeUtil.hpp"
34 #include "vkCmdUtil.hpp"
35 #include "vkBarrierUtil.hpp"
36 #include "vkImageUtil.hpp"
37
38 #include "tcuVector.hpp"
39 #include "tcuMaybe.hpp"
40 #include "tcuTestLog.hpp"
41
42 #include "deUniquePtr.hpp"
43
44 #include <sstream>
45 #include <string>
46 #include <memory>
47 #include <vector>
48 #include <algorithm>
49
50 namespace vkt
51 {
52 namespace rasterization
53 {
54
55 namespace
56 {
57
58 enum class CaseType
59 {
60 KILL,
61 DEMOTE,
62 TERMINATE_INVOCATION,
63 SAMPLE_MASK_BEFORE,
64 SAMPLE_MASK_AFTER,
65 ALPHA_COVERAGE_BEFORE,
66 ALPHA_COVERAGE_AFTER,
67 DEPTH_BOUNDS,
68 STENCIL_NEVER,
69 DEPTH_NEVER,
70 };
71
72 constexpr deUint32 kFramebufferWidth = 32u;
73 constexpr deUint32 kFramebufferHeight = 32u;
74 constexpr deUint32 kTotalPixels = kFramebufferWidth * kFramebufferHeight;
75
76 constexpr vk::VkFormat kColorFormat = vk::VK_FORMAT_R8G8B8A8_UNORM;
77 constexpr vk::VkFormatFeatureFlags kNeededDSFeatures = vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
78 // VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT must be supported for one of these two, according to the spec.
79 const vk::VkFormat kDepthStencilFormats[] = { vk::VK_FORMAT_D32_SFLOAT_S8_UINT, vk::VK_FORMAT_D24_UNORM_S8_UINT };
80
81 struct DepthBoundsParameters
82 {
83 float minDepthBounds;
84 float maxDepthBounds;
85 float depthValue;
86 };
87
88 struct TestParams
89 {
90 CaseType caseType;
91 tcu::Vec4 clearColor;
92 tcu::Vec4 drawColor;
93 bool colorAtEnd;
94 tcu::Maybe<DepthBoundsParameters> depthBoundsParams;
95
TestParamsvkt::rasterization::__anon4014906e0111::TestParams96 TestParams (CaseType type, const tcu::Vec4& clearColor_, const tcu::Vec4& drawColor_, bool colorAtEnd_, const tcu::Maybe<DepthBoundsParameters>& depthBoundsParams_)
97 : caseType (type)
98 , clearColor (clearColor_)
99 , drawColor (drawColor_)
100 , colorAtEnd (colorAtEnd_)
101 , depthBoundsParams (depthBoundsParams_)
102 {
103 if (caseType == CaseType::DEPTH_BOUNDS)
104 DE_ASSERT(static_cast<bool>(depthBoundsParams));
105 }
106 };
107
expectClearColor(CaseType caseType)108 bool expectClearColor (CaseType caseType)
109 {
110 return (caseType != CaseType::ALPHA_COVERAGE_BEFORE && caseType != CaseType::ALPHA_COVERAGE_AFTER);
111 }
112
needsDepthStencilAttachment(CaseType caseType)113 bool needsDepthStencilAttachment (CaseType caseType)
114 {
115 return (caseType == CaseType::DEPTH_BOUNDS || caseType == CaseType::DEPTH_NEVER || caseType == CaseType::STENCIL_NEVER);
116 }
117
makeVkBool32(bool value)118 vk::VkBool32 makeVkBool32 (bool value)
119 {
120 return (value ? VK_TRUE : VK_FALSE);
121 }
122
123 class FragSideEffectsTestCase : public vkt::TestCase
124 {
125 public:
126 FragSideEffectsTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TestParams& params);
~FragSideEffectsTestCase(void)127 virtual ~FragSideEffectsTestCase (void) {}
128
129 virtual void checkSupport (Context& context) const;
130 virtual void initPrograms (vk::SourceCollections& programCollection) const;
131 virtual TestInstance* createInstance (Context& context) const;
132
133 private:
134 TestParams m_params;
135 };
136
137 class FragSideEffectsInstance : public vkt::TestInstance
138 {
139 public:
140 FragSideEffectsInstance (Context& context, const TestParams& params);
~FragSideEffectsInstance(void)141 virtual ~FragSideEffectsInstance (void) {}
142
143 virtual tcu::TestStatus iterate (void);
144
145 private:
146 TestParams m_params;
147 };
148
FragSideEffectsTestCase(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const TestParams & params)149 FragSideEffectsTestCase::FragSideEffectsTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TestParams& params)
150 : vkt::TestCase (testCtx, name, description)
151 , m_params (params)
152 {}
153
checkSupport(Context & context) const154 void FragSideEffectsTestCase::checkSupport (Context& context) const
155 {
156 const auto& features = context.getDeviceFeatures();
157
158 if (!features.fragmentStoresAndAtomics)
159 TCU_THROW(NotSupportedError, "Fragment shader stores and atomics not supported");
160
161 if (m_params.caseType == CaseType::DEPTH_BOUNDS)
162 {
163 if (!features.depthBounds)
164 TCU_THROW(NotSupportedError, "Depth bounds test not supported");
165 }
166 else if (m_params.caseType == CaseType::DEMOTE)
167 {
168 context.requireDeviceFunctionality("VK_EXT_shader_demote_to_helper_invocation");
169 }
170 else if (m_params.caseType == CaseType::TERMINATE_INVOCATION)
171 {
172 context.requireDeviceFunctionality("VK_KHR_shader_terminate_invocation");
173 }
174 }
175
initPrograms(vk::SourceCollections & programCollection) const176 void FragSideEffectsTestCase::initPrograms (vk::SourceCollections& programCollection) const
177 {
178 std::ostringstream headers;
179 std::ostringstream before;
180 std::ostringstream after;
181
182 std::ostringstream vert;
183 std::ostringstream frag;
184
185 // Depth should be 0 by default unless provided by the depth bounds parameters.
186 const float meshDepth = (m_params.depthBoundsParams ? m_params.depthBoundsParams.get().depthValue : 0.0f);
187 const auto& drawColor = m_params.drawColor;
188
189 vert
190 << "#version 450\n"
191 << "\n"
192 << "layout (location=0) in vec2 inPos;\n"
193 << "\n"
194 << "void main() {\n"
195 << " gl_Position = vec4(inPos, " << meshDepth << ", 1.0);\n"
196 << "}\n"
197 ;
198
199 // Prepare output color statement to be used before or after SSBO write.
200 std::ostringstream colorStatement;
201 if (m_params.caseType == CaseType::ALPHA_COVERAGE_BEFORE || m_params.caseType == CaseType::ALPHA_COVERAGE_AFTER)
202 {
203 // In the alpha coverage cases the alpha color value is supposed to be 0.
204 DE_ASSERT(m_params.drawColor.w() == 0.0f);
205
206 // Leave out the alpha component for these cases.
207 colorStatement << " outColor.rgb = vec3(" << drawColor.x() << ", " << drawColor.y() << ", " << drawColor.z() << ");\n";
208 }
209 else
210 {
211 colorStatement << " outColor = vec4(" << drawColor.x() << ", " << drawColor.y() << ", " << drawColor.z() << ", " << drawColor.w() << ");\n";
212 }
213
214 switch (m_params.caseType)
215 {
216 case CaseType::KILL:
217 after << " discard;\n";
218 break;
219 case CaseType::DEMOTE:
220 headers << "#extension GL_EXT_demote_to_helper_invocation : enable\n";
221 after << " demote;\n";
222 break;
223 case CaseType::TERMINATE_INVOCATION:
224 headers << "#extension GL_EXT_terminate_invocation : enable\n";
225 after << " terminateInvocation;\n";
226 break;
227 case CaseType::SAMPLE_MASK_BEFORE:
228 before << " gl_SampleMask[0] = 0;\n";
229 break;
230 case CaseType::SAMPLE_MASK_AFTER:
231 after << " gl_SampleMask[0] = 0;\n";
232 break;
233 case CaseType::ALPHA_COVERAGE_BEFORE:
234 before << " outColor.a = float(" << drawColor.w() << ");\n";
235 break;
236 case CaseType::ALPHA_COVERAGE_AFTER:
237 after << " outColor.a = float(" << drawColor.w() << ");\n";
238 break;
239 case CaseType::DEPTH_BOUNDS:
240 case CaseType::STENCIL_NEVER:
241 case CaseType::DEPTH_NEVER:
242 break;
243 default:
244 DE_ASSERT(false); break;
245 }
246
247 frag
248 << "#version 450\n"
249 << "layout(set=0, binding=0, std430) buffer OutputBuffer {\n"
250 << " int val[" << kTotalPixels << "];\n"
251 << "} outBuffer;\n"
252 << "layout (location=0) out vec4 outColor;\n"
253 << headers.str()
254 << "\n"
255 << "void main() {\n"
256 << " const ivec2 fragCoord = ivec2(gl_FragCoord);\n"
257 << " const int bufferIndex = (fragCoord.y * " << kFramebufferWidth << ") + fragCoord.x;\n"
258 << (m_params.colorAtEnd ? "" : colorStatement.str())
259 << before.str()
260 << " outBuffer.val[bufferIndex] = 1;\n"
261 << after.str()
262 << (m_params.colorAtEnd ? colorStatement.str() : "")
263 << "}\n"
264 ;
265
266 programCollection.glslSources.add("vert") << glu::VertexSource(vert.str());
267 programCollection.glslSources.add("frag") << glu::FragmentSource(frag.str());
268 }
269
createInstance(Context & context) const270 TestInstance* FragSideEffectsTestCase::createInstance (Context& context) const
271 {
272 return new FragSideEffectsInstance(context, m_params);
273 }
274
FragSideEffectsInstance(Context & context,const TestParams & params)275 FragSideEffectsInstance::FragSideEffectsInstance (Context& context, const TestParams& params)
276 : vkt::TestInstance (context)
277 , m_params (params)
278 {}
279
iterate(void)280 tcu::TestStatus FragSideEffectsInstance::iterate (void)
281 {
282 const auto& vki = m_context.getInstanceInterface();
283 const auto physicalDevice = m_context.getPhysicalDevice();
284 const auto& vkd = m_context.getDeviceInterface();
285 const auto device = m_context.getDevice();
286 auto& alloc = m_context.getDefaultAllocator();
287 const auto queue = m_context.getUniversalQueue();
288 const auto queueIndex = m_context.getUniversalQueueFamilyIndex();
289
290 // Color and depth/stencil images.
291
292 const vk::VkImageCreateInfo colorCreateInfo =
293 {
294 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
295 nullptr, // const void* pNext;
296 0u, // VkImageCreateFlags flags;
297 vk::VK_IMAGE_TYPE_2D, // VkImageType imageType;
298 kColorFormat, // VkFormat format;
299 vk::makeExtent3D(kFramebufferWidth, kFramebufferHeight, 1u), // VkExtent3D extent;
300 1u, // deUint32 mipLevels;
301 1u, // deUint32 arrayLayers;
302 vk::VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
303 vk::VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
304 (vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT), // VkImageUsageFlags usage;
305 vk::VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
306 0u, // deUint32 queueFamilyIndexCount;
307 nullptr, // const deUint32* pQueueFamilyIndices;
308 vk::VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
309 };
310 vk::ImageWithMemory colorImage(vkd, device, alloc, colorCreateInfo, vk::MemoryRequirement::Any);
311
312 std::unique_ptr<vk::ImageWithMemory> depthStencilImage;
313 vk::VkFormat depthStencilFormat = vk::VK_FORMAT_UNDEFINED;
314
315 if (needsDepthStencilAttachment(m_params.caseType))
316 {
317 // Find available image format first.
318 for (int i = 0; i < DE_LENGTH_OF_ARRAY(kDepthStencilFormats); ++i)
319 {
320 const auto dsFormatProperties = vk::getPhysicalDeviceFormatProperties(vki, physicalDevice, kDepthStencilFormats[i]);
321 if ((dsFormatProperties.optimalTilingFeatures & kNeededDSFeatures) == kNeededDSFeatures)
322 {
323 depthStencilFormat = kDepthStencilFormats[i];
324 break;
325 }
326 }
327
328 if (depthStencilFormat == vk::VK_FORMAT_UNDEFINED)
329 TCU_FAIL("No suitable depth/stencil format found");
330
331 const vk::VkImageCreateInfo depthStencilCreateInfo =
332 {
333 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
334 nullptr, // const void* pNext;
335 0u, // VkImageCreateFlags flags;
336 vk::VK_IMAGE_TYPE_2D, // VkImageType imageType;
337 depthStencilFormat, // VkFormat format;
338 vk::makeExtent3D(kFramebufferWidth, kFramebufferHeight, 1u), // VkExtent3D extent;
339 1u, // deUint32 mipLevels;
340 1u, // deUint32 arrayLayers;
341 vk::VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
342 vk::VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
343 vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, // VkImageUsageFlags usage;
344 vk::VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
345 0u, // deUint32 queueFamilyIndexCount;
346 nullptr, // const deUint32* pQueueFamilyIndices;
347 vk::VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
348 };
349
350 depthStencilImage.reset(new vk::ImageWithMemory(vkd, device, alloc, depthStencilCreateInfo, vk::MemoryRequirement::Any));
351 }
352
353 // Image views.
354 const auto colorSubresourceRange = vk::makeImageSubresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
355 const auto colorImageView = vk::makeImageView(vkd, device, colorImage.get(), vk::VK_IMAGE_VIEW_TYPE_2D, kColorFormat, colorSubresourceRange);
356
357 vk::Move<vk::VkImageView> depthStencilImageView;
358 if (depthStencilImage)
359 {
360 const auto depthStencilSubresourceRange = vk::makeImageSubresourceRange((vk::VK_IMAGE_ASPECT_DEPTH_BIT | vk::VK_IMAGE_ASPECT_STENCIL_BIT), 0u, 1u, 0u, 1u);
361 depthStencilImageView = vk::makeImageView(vkd, device, depthStencilImage.get()->get(), vk::VK_IMAGE_VIEW_TYPE_2D, depthStencilFormat, depthStencilSubresourceRange);
362 }
363
364 // Color image buffer.
365 const auto tcuFormat = vk::mapVkFormat(kColorFormat);
366 const auto colorImageBufferSize = static_cast<vk::VkDeviceSize>(kTotalPixels * tcuFormat.getPixelSize());
367 const auto colorImageBufferInfo = vk::makeBufferCreateInfo(colorImageBufferSize, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT);
368 vk::BufferWithMemory colorImageBuffer(vkd, device, alloc, colorImageBufferInfo, vk::MemoryRequirement::HostVisible);
369
370 // Vertex buffer.
371 const std::vector<tcu::Vec2> fullScreenQuad =
372 {
373 tcu::Vec2(-1.0f, 1.0f),
374 tcu::Vec2( 1.0f, 1.0f),
375 tcu::Vec2( 1.0f, -1.0f),
376 tcu::Vec2(-1.0f, 1.0f),
377 tcu::Vec2( 1.0f, -1.0f),
378 tcu::Vec2(-1.0f, -1.0f),
379 };
380
381 const auto vertexBufferSize = static_cast<vk::VkDeviceSize>(fullScreenQuad.size() * sizeof(decltype(fullScreenQuad)::value_type));
382 const auto vertexBufferInfo = vk::makeBufferCreateInfo(vertexBufferSize, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
383 const vk::VkDeviceSize vertexBufferOffset = 0ull;
384 vk::BufferWithMemory vertexBuffer (vkd, device, alloc, vertexBufferInfo, vk::MemoryRequirement::HostVisible);
385 const auto& vertexBufferAlloc = vertexBuffer.getAllocation();
386
387 deMemcpy(vertexBufferAlloc.getHostPtr(), fullScreenQuad.data(), static_cast<size_t>(vertexBufferSize));
388 vk::flushAlloc(vkd, device, vertexBufferAlloc);
389
390 // Storage buffer.
391 const auto storageBufferSize = static_cast<vk::VkDeviceSize>(kTotalPixels * sizeof(deInt32));
392 const auto storageBufferInfo = vk::makeBufferCreateInfo(storageBufferSize, (vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
393 vk::BufferWithMemory storageBuffer (vkd, device, alloc, storageBufferInfo, vk::MemoryRequirement::HostVisible);
394 const auto& storageBufferAlloc = storageBuffer.getAllocation();
395
396 deMemset(storageBufferAlloc.getHostPtr(), 0, static_cast<size_t>(storageBufferSize));
397 vk::flushAlloc(vkd, device, storageBufferAlloc);
398
399 // Descriptor set layout.
400 vk::DescriptorSetLayoutBuilder layoutBuilder;
401 layoutBuilder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_FRAGMENT_BIT);
402 const auto descriptorSetLayout = layoutBuilder.build(vkd, device);
403
404 // Pipeline layout.
405 const auto pipelineLayout = vk::makePipelineLayout(vkd, device, descriptorSetLayout.get());
406
407 // Descriptor pool.
408 vk::DescriptorPoolBuilder poolBuilder;
409 poolBuilder.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
410 const auto descriptorPool = poolBuilder.build(vkd, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
411
412 // Descriptor set.
413 const auto descriptorSet = vk::makeDescriptorSet(vkd, device, descriptorPool.get(), descriptorSetLayout.get());
414
415 // Update descriptor set.
416 vk::DescriptorSetUpdateBuilder updateBuilder;
417 const auto descriptorBufferInfo = vk::makeDescriptorBufferInfo(storageBuffer.get(), 0u, storageBufferSize);
418 updateBuilder.writeSingle(descriptorSet.get(), vk::DescriptorSetUpdateBuilder::Location::binding(0), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorBufferInfo);
419 updateBuilder.update(vkd, device);
420
421 // Render pass.
422 const auto renderPass = vk::makeRenderPass(vkd, device, kColorFormat, depthStencilFormat);
423
424 // Framebuffer.
425 std::vector<vk::VkImageView> imageViews(1u, colorImageView.get());
426 if (depthStencilImage)
427 imageViews.push_back(depthStencilImageView.get());
428
429 const auto framebuffer = vk::makeFramebuffer(vkd, device, renderPass.get(), static_cast<deUint32>(imageViews.size()), imageViews.data(), kFramebufferWidth, kFramebufferHeight);
430
431 // Shader modules.
432 const auto vertModule = vk::createShaderModule(vkd, device, m_context.getBinaryCollection().get("vert"), 0u);
433 const auto fragModule = vk::createShaderModule(vkd, device, m_context.getBinaryCollection().get("frag"), 0u);
434
435 // Vertex input state.
436 const auto vertexBinding = vk::makeVertexInputBindingDescription(0u, static_cast<deUint32>(sizeof(tcu::Vec2)), vk::VK_VERTEX_INPUT_RATE_VERTEX);
437 const auto vertexAttributes = vk::makeVertexInputAttributeDescription(0u, 0u, vk::VK_FORMAT_R32G32_SFLOAT, 0u);
438
439 const vk::VkPipelineVertexInputStateCreateInfo vertexInputInfo =
440 {
441 vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
442 nullptr, // const void* pNext;
443 0u, // VkPipelineVertexInputStateCreateFlags flags;
444 1u, // deUint32 vertexBindingDescriptionCount;
445 &vertexBinding, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
446 1u, // deUint32 vertexAttributeDescriptionCount;
447 &vertexAttributes, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
448 };
449
450 // Input assembly state.
451 const vk::VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo =
452 {
453 vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
454 nullptr, // const void* pNext;
455 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
456 vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
457 VK_FALSE, // VkBool32 primitiveRestartEnable;
458 };
459
460 // Viewport state.
461 const auto viewport = vk::makeViewport(kFramebufferWidth, kFramebufferHeight);
462 const auto scissor = vk::makeRect2D(kFramebufferWidth, kFramebufferHeight);
463
464 const vk::VkPipelineViewportStateCreateInfo viewportInfo =
465 {
466 vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
467 nullptr, // const void* pNext;
468 0u, // VkPipelineViewportStateCreateFlags flags;
469 1u, // deUint32 viewportCount;
470 &viewport, // const VkViewport* pViewports;
471 1u, // deUint32 scissorCount;
472 &scissor, // const VkRect2D* pScissors;
473 };
474
475 // Rasterization state.
476 const vk::VkPipelineRasterizationStateCreateInfo rasterizationInfo =
477 {
478 vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
479 nullptr, // const void* pNext;
480 0u, // VkPipelineRasterizationStateCreateFlags flags;
481 VK_FALSE, // VkBool32 depthClampEnable;
482 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
483 vk::VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
484 vk::VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
485 vk::VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
486 VK_FALSE, // VkBool32 depthBiasEnable;
487 0.0f, // float depthBiasConstantFactor;
488 0.0f, // float depthBiasClamp;
489 0.0f, // float depthBiasSlopeFactor;
490 1.0f, // float lineWidth;
491 };
492
493 // Multisample state.
494 const bool alphaToCoverageEnable = (m_params.caseType == CaseType::ALPHA_COVERAGE_BEFORE || m_params.caseType == CaseType::ALPHA_COVERAGE_AFTER);
495 const vk::VkPipelineMultisampleStateCreateInfo multisampleInfo =
496 {
497 vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
498 nullptr, // const void* pNext;
499 0u, // VkPipelineMultisampleStateCreateFlags flags;
500 vk::VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
501 VK_FALSE, // VkBool32 sampleShadingEnable;
502 0.0f, // float minSampleShading;
503 nullptr, // const VkSampleMask* pSampleMask;
504 makeVkBool32(alphaToCoverageEnable), // VkBool32 alphaToCoverageEnable;
505 VK_FALSE, // VkBool32 alphaToOneEnable;
506 };
507
508 // Depth/stencil state.
509 const auto enableDepthBounds = makeVkBool32(m_params.caseType == CaseType::DEPTH_BOUNDS);
510 const auto enableDepthStencilTest = static_cast<bool>(depthStencilImage);
511
512 const auto depthCompareOp = ((m_params.caseType == CaseType::DEPTH_NEVER) ? vk::VK_COMPARE_OP_NEVER : vk::VK_COMPARE_OP_ALWAYS);
513 const auto stencilCompareOp = ((m_params.caseType == CaseType::STENCIL_NEVER) ? vk::VK_COMPARE_OP_NEVER : vk::VK_COMPARE_OP_ALWAYS);
514 const auto stencilOpState = vk::makeStencilOpState(vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, vk::VK_STENCIL_OP_KEEP, stencilCompareOp, 0xFFu, 0xFFu, 0u);
515
516 const vk::VkPipelineDepthStencilStateCreateInfo depthStencilInfo =
517 {
518 vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
519 nullptr, // const void* pNext;
520 0u, // VkPipelineDepthStencilStateCreateFlags flags;
521 enableDepthStencilTest, // VkBool32 depthTestEnable;
522 enableDepthStencilTest, // VkBool32 depthWriteEnable;
523 depthCompareOp, // VkCompareOp depthCompareOp;
524 enableDepthBounds, // VkBool32 depthBoundsTestEnable;
525 enableDepthStencilTest, // VkBool32 stencilTestEnable;
526 stencilOpState, // VkStencilOpState front;
527 stencilOpState, // VkStencilOpState back;
528 (enableDepthBounds ? m_params.depthBoundsParams.get().minDepthBounds : 0.0f), // float minDepthBounds;
529 (enableDepthBounds ? m_params.depthBoundsParams.get().maxDepthBounds : 1.0f), // float maxDepthBounds;
530 };
531
532 // Color blend state.
533 const vk::VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
534 {
535 VK_FALSE, // VkBool32 blendEnable
536 vk::VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor
537 vk::VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor
538 vk::VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp
539 vk::VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor
540 vk::VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor
541 vk::VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp
542 vk::VK_COLOR_COMPONENT_R_BIT // VkColorComponentFlags colorWriteMask
543 | vk::VK_COLOR_COMPONENT_G_BIT
544 | vk::VK_COLOR_COMPONENT_B_BIT
545 | vk::VK_COLOR_COMPONENT_A_BIT
546 };
547
548 const vk::VkPipelineColorBlendStateCreateInfo colorBlendInfo =
549 {
550 vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
551 nullptr, // const void* pNext;
552 0u, // VkPipelineColorBlendStateCreateFlags flags;
553 VK_FALSE, // VkBool32 logicOpEnable;
554 vk::VK_LOGIC_OP_NO_OP, // VkLogicOp logicOp;
555 1u, // deUint32 attachmentCount;
556 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
557 { .0f, .0f, .0f, .0f }, // float blendConstants[4];
558 };
559
560 // Graphics pipeline.
561 const auto graphicsPipeline = vk::makeGraphicsPipeline(
562 vkd, device, pipelineLayout.get(),
563 vertModule.get(), DE_NULL, DE_NULL, DE_NULL, fragModule.get(),
564 renderPass.get(), 0u,
565 &vertexInputInfo,
566 &inputAssemblyInfo,
567 nullptr,
568 &viewportInfo,
569 &rasterizationInfo,
570 &multisampleInfo,
571 &depthStencilInfo,
572 &colorBlendInfo);
573
574 // Command buffer.
575 const auto cmdPool = vk::makeCommandPool(vkd, device, queueIndex);
576 const auto cmdBufferPtr = vk::allocateCommandBuffer(vkd, device, cmdPool.get(), vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
577 const auto cmdBuffer = cmdBufferPtr.get();
578
579 // Draw full-screen quad.
580 std::vector<vk::VkClearValue> clearValues;
581 clearValues.push_back(vk::makeClearValueColor(m_params.clearColor));
582 clearValues.push_back(vk::makeClearValueDepthStencil(1.0f, 0u));
583
584 vk::beginCommandBuffer(vkd, cmdBuffer);
585 vk::beginRenderPass(vkd, cmdBuffer, renderPass.get(), framebuffer.get(), vk::makeRect2D(kFramebufferWidth, kFramebufferHeight), static_cast<deUint32>(clearValues.size()), clearValues.data());
586 vkd.cmdBindPipeline(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline.get());
587 vkd.cmdBindDescriptorSets(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout.get(), 0u, 1u, &descriptorSet.get(), 0u, nullptr);
588 vkd.cmdBindVertexBuffers(cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
589 vkd.cmdDraw(cmdBuffer, static_cast<deUint32>(fullScreenQuad.size()), 1u, 0u, 0u);
590 vk::endRenderPass(vkd, cmdBuffer);
591
592 // Image and buffer barriers.
593
594 // Storage buffer frag-write to host-read barrier.
595 const auto storageBufferBarrier = vk::makeBufferMemoryBarrier(vk::VK_ACCESS_SHADER_WRITE_BIT, vk::VK_ACCESS_HOST_READ_BIT, storageBuffer.get(), 0u, VK_WHOLE_SIZE);
596
597 // Color image frag-write to transfer-read barrier.
598 const auto colorImageBarrier = vk::makeImageMemoryBarrier(vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, vk::VK_ACCESS_TRANSFER_READ_BIT, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, colorImage.get(), colorSubresourceRange);
599
600 // Color buffer transfer-write to host-read barrier.
601 const auto colorBufferBarrier = vk::makeBufferMemoryBarrier(vk::VK_ACCESS_TRANSFER_WRITE_BIT, vk::VK_ACCESS_HOST_READ_BIT, colorImageBuffer.get(), 0u, VK_WHOLE_SIZE);
602
603 vk::cmdPipelineBufferMemoryBarrier(vkd, cmdBuffer, vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, &storageBufferBarrier);
604 vk::cmdPipelineImageMemoryBarrier(vkd, cmdBuffer, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, &colorImageBarrier);
605 const auto copyRegion = vk::makeBufferImageCopy(vk::makeExtent3D(kFramebufferWidth, kFramebufferHeight, 1u), vk::makeImageSubresourceLayers(vk::VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u));
606 vkd.cmdCopyImageToBuffer(cmdBuffer, colorImage.get(), vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, colorImageBuffer.get(), 1u, ©Region);
607 vk::cmdPipelineBufferMemoryBarrier(vkd, cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, &colorBufferBarrier);
608
609 vk::endCommandBuffer(vkd, cmdBuffer);
610 vk::submitCommandsAndWait(vkd, device, queue, cmdBuffer);
611
612 // Check output.
613 {
614 // Check SSBO contents.
615 vk::invalidateAlloc(vkd, device, storageBufferAlloc);
616 const auto bufferElements = reinterpret_cast<const deInt32*>(storageBufferAlloc.getHostPtr());
617
618 for (deUint32 i = 0; i < kTotalPixels; ++i)
619 {
620 if (bufferElements[i] != 1)
621 {
622 std::ostringstream msg;
623 msg << "Unexpected value in storage buffer element " << i;
624 return tcu::TestStatus::fail("Fail: " + msg.str());
625 }
626 }
627 }
628
629 {
630 // Check color attachment.
631 std::vector<tcu::Vec4> expectedColors(1u, m_params.clearColor);
632 if (!expectClearColor(m_params.caseType))
633 expectedColors.push_back(m_params.drawColor);
634
635 const auto& colorImageBufferAlloc = colorImageBuffer.getAllocation();
636 vk::invalidateAlloc(vkd, device, colorImageBufferAlloc);
637
638 const auto iWidth = static_cast<int>(kFramebufferWidth);
639 const auto iHeight = static_cast<int>(kFramebufferHeight);
640
641 tcu::ConstPixelBufferAccess colorPixels (tcuFormat, iWidth, iHeight, 1, colorImageBufferAlloc.getHostPtr());
642 std::vector<deUint8> errorMaskBuffer (kTotalPixels * tcuFormat.getPixelSize(), 0u);
643 tcu::PixelBufferAccess errorMask (tcuFormat, iWidth, iHeight, 1, errorMaskBuffer.data());
644 const tcu::Vec4 green (0.0f, 1.0f, 0.0f, 1.0f);
645 const tcu::Vec4 red (1.0f, 0.0f, 0.0f, 1.0f);
646 bool allPixOk = true;
647
648 for (int i = 0; i < iWidth; ++i)
649 for (int j = 0; j < iHeight; ++j)
650 {
651 const auto pixel = colorPixels.getPixel(i, j);
652 const bool pixOk = std::any_of(begin(expectedColors), end(expectedColors), [&pixel](const tcu::Vec4& expected) -> bool { return (pixel == expected); });
653 errorMask.setPixel((pixOk ? green : red), i, j);
654 if (!pixOk)
655 allPixOk = false;
656 }
657
658 if (!allPixOk)
659 {
660 auto& testLog = m_context.getTestContext().getLog();
661 testLog << tcu::TestLog::Image("ColorBuffer", "Result color buffer", colorPixels);
662 testLog << tcu::TestLog::Image("ErrorMask", "Error mask with errors marked in red", errorMask);
663 return tcu::TestStatus::fail("Fail: color buffer with unexpected values; check logged images");
664 }
665 }
666
667 return tcu::TestStatus::pass("Pass");
668 }
669
670 } // anonymous
671
createFragSideEffectsTests(tcu::TestContext & testCtx)672 tcu::TestCaseGroup* createFragSideEffectsTests (tcu::TestContext& testCtx)
673 {
674 de::MovePtr<tcu::TestCaseGroup> fragSideEffectsGroup(new tcu::TestCaseGroup(testCtx, "frag_side_effects", "Test fragment shader side effects are not removed by optimizations"));
675
676 const tcu::Vec4 kDefaultClearColor (0.0f, 0.0f, 0.0f, 1.0f);
677 const tcu::Vec4 kDefaultDrawColor (0.0f, 0.0f, 1.0f, 1.0f);
678 const auto kDefaultDepthBoundsParams = tcu::Nothing;
679
680 static const struct
681 {
682 bool colorAtEnd;
683 std::string name;
684 std::string desc;
685 } kColorOrders[] =
686 {
687 { false, "color_at_beginning", "Fragment shader output assignment at the beginning of the shader" },
688 { true, "color_at_end", "Fragment shader output assignment at the end of the shader" },
689 };
690
691 for (int i = 0; i < DE_LENGTH_OF_ARRAY(kColorOrders); ++i)
692 {
693 de::MovePtr<tcu::TestCaseGroup> colorOrderGroup(new tcu::TestCaseGroup(testCtx, kColorOrders[i].name.c_str(), kColorOrders[i].desc.c_str()));
694 const bool colorAtEnd = kColorOrders[i].colorAtEnd;
695
696 {
697 TestParams params(CaseType::KILL, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, kDefaultDepthBoundsParams);
698 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "kill", "OpKill after SSBO write", params));
699 }
700 {
701 TestParams params(CaseType::DEMOTE, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, kDefaultDepthBoundsParams);
702 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "demote", "OpDemoteToHelperInvocation after SSBO write", params));
703 }
704 {
705 TestParams params(CaseType::TERMINATE_INVOCATION, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, kDefaultDepthBoundsParams);
706 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "terminate_invocation", "OpTerminateInvocation after SSBO write", params));
707 }
708 {
709 TestParams params(CaseType::SAMPLE_MASK_BEFORE, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, kDefaultDepthBoundsParams);
710 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "sample_mask_before", "Set sample mask to zero before SSBO write", params));
711 }
712 {
713 TestParams params(CaseType::SAMPLE_MASK_AFTER, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, kDefaultDepthBoundsParams);
714 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "sample_mask_after", "Set sample mask to zero after SSBO write", params));
715 }
716 {
717 TestParams params(CaseType::STENCIL_NEVER, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, kDefaultDepthBoundsParams);
718 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "stencil_never", "SSBO write with stencil test never passes", params));
719 }
720 {
721 TestParams params(CaseType::DEPTH_NEVER, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, kDefaultDepthBoundsParams);
722 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "depth_never", "SSBO write with depth test never passes", params));
723 }
724 {
725 const tcu::Vec4 drawColor(kDefaultDrawColor.x(), kDefaultDrawColor.y(), kDefaultDrawColor.z(), 0.0f);
726 {
727 TestParams params(CaseType::ALPHA_COVERAGE_BEFORE, kDefaultClearColor, drawColor, colorAtEnd, kDefaultDepthBoundsParams);
728 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "alpha_coverage_before", "Enable alpha coverage and draw with alpha zero before SSBO write", params));
729 }
730 {
731 TestParams params(CaseType::ALPHA_COVERAGE_AFTER, kDefaultClearColor, drawColor, colorAtEnd, kDefaultDepthBoundsParams);
732 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "alpha_coverage_after", "Enable alpha coverage and draw with alpha zero after SSBO write", params));
733 }
734 }
735 {
736 DepthBoundsParameters depthBoundsParams = {0.25f, 0.5f, 0.75f}; // min, max, draw depth.
737 TestParams params(CaseType::DEPTH_BOUNDS, kDefaultClearColor, kDefaultDrawColor, colorAtEnd, tcu::just(depthBoundsParams));
738 colorOrderGroup->addChild(new FragSideEffectsTestCase(testCtx, "depth_bounds", "SSBO write with depth bounds test failing", params));
739 }
740
741 fragSideEffectsGroup->addChild(colorOrderGroup.release());
742 }
743
744 return fragSideEffectsGroup.release();
745 }
746
747 } // rasterization
748 } // vkt
749