1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2017-2019 The Khronos Group Inc.
6 * Copyright (c) 2018-2020 NVIDIA Corporation
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 * \brief Tests for VK_KHR_fragment_shading_rate
23 * The test renders 9*9 triangles, where each triangle has one of the valid
24 * fragment sizes ({1,2,4},{1,2,4}) (clamped to implementation limits) for
25 * each of the pipeline shading rate and the primitive shading rate. The
26 * fragment shader does an atomic add to a memory location to get a unique
27 * identifier for the fragment, and outputs the primitive ID, atomic counter,
28 * fragment size, and some other info the the color output. Then a compute
29 * shader copies this to buffer memory, and the host verifies several
30 * properties of the output. For example, if a sample has a particular
31 * primitive ID and atomic value, then all other samples in the tile with
32 * the same primitive ID should have the same atomic value.
33 *//*--------------------------------------------------------------------*/
35 #include "vktFragmentShadingRateBasic.hpp"
37 #include "vkBufferWithMemory.hpp"
38 #include "vkImageWithMemory.hpp"
39 #include "vkQueryUtil.hpp"
40 #include "vkBuilderUtil.hpp"
41 #include "vkCmdUtil.hpp"
42 #include "vkTypeUtil.hpp"
43 #include "vkObjUtil.hpp"
44 #include "vkImageUtil.hpp"
46 #include "vktTestGroupUtil.hpp"
47 #include "vktTestCase.hpp"
52 #include "deSharedPtr.hpp"
55 #include "tcuTestCase.hpp"
56 #include "tcuTestLog.hpp"
64 namespace FragmentShadingRate
71 #define NUM_TRIANGLES (9*9)
73 enum class AttachmentUsage
78 WITH_ATTACHMENT_WITHOUT_IMAGEVIEW, // No imageview at VkRenderingFragmentShadingRateAttachmentInfoKHR.
83 SharedGroupParams groupParams;
85 VkExtent2D framebufferDim;
86 VkSampleCountFlagBits samples;
87 VkFragmentShadingRateCombinerOpKHR combinerOp[2];
88 AttachmentUsage attachmentUsage;
89 bool shaderWritesRate;
92 bool useApiSampleMask;
94 bool conservativeEnable;
95 VkConservativeRasterizationModeEXT conservativeMode;
96 bool useDepthStencil; // == fragDepth || fragStencil
101 bool srLayered; // colorLayered must also be true
102 deUint32 numColorLayers;
104 bool correlationMask;
106 bool sampleLocations;
107 bool sampleShadingEnable;
108 bool sampleShadingInput;
110 bool earlyAndLateTest;
112 bool useAttachment () const
114 return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT);
117 bool useAttachmentWithoutImageView () const
119 return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW);
123 class FSRTestInstance : public TestInstance
126 FSRTestInstance (Context& context, const CaseDef& data);
127 ~FSRTestInstance (void);
128 tcu::TestStatus iterate (void);
134 // Cache simulated combiner operations, to avoid recomputing per-sample
135 deInt32 m_simulateValueCount;
136 vector<deInt32> m_simulateCache;
137 // Cache mapping of primitive ID to pipeline/primitive shading rate
138 vector<deInt32> m_primIDToPrimitiveShadingRate;
139 vector<deInt32> m_primIDToPipelineShadingRate;
140 deUint32 m_supportedFragmentShadingRateCount;
141 vector<VkPhysicalDeviceFragmentShadingRateKHR> m_supportedFragmentShadingRates;
142 VkPhysicalDeviceFragmentShadingRatePropertiesKHR m_shadingRateProperties;
146 void preRenderCommands (VkCommandBuffer cmdBuffer,
147 ImageWithMemory* cbImage,
148 ImageWithMemory* dsImage,
149 ImageWithMemory* derivImage,
150 deUint32 derivNumLevels,
151 ImageWithMemory* srImage,
152 VkImageLayout srLayout,
153 BufferWithMemory* srFillBuffer,
154 deUint32 numSRLayers,
158 const VkClearValue& clearColor,
159 const VkClearValue& clearDepthStencil);
160 void beginLegacyRender (VkCommandBuffer cmdBuffer,
161 VkRenderPass renderPass,
162 VkFramebuffer framebuffer,
163 VkImageView srImageView,
164 VkImageView cbImageView,
165 VkImageView dsImageView,
166 bool imagelessFB) const;
167 void drawCommands (VkCommandBuffer cmdBuffer,
168 std::vector<GraphicsPipelineWrapper>& pipelines,
169 const std::vector<VkViewport>& viewports,
170 const std::vector<VkRect2D>& scissors,
171 const VkPipelineLayout pipelineLayout,
172 const VkRenderPass renderPass,
173 const VkPipelineVertexInputStateCreateInfo* vertexInputState,
174 const VkPipelineDynamicStateCreateInfo* dynamicState,
175 const VkPipelineRasterizationStateCreateInfo* rasterizationState,
176 const VkPipelineDepthStencilStateCreateInfo* depthStencilState,
177 const VkPipelineMultisampleStateCreateInfo* multisampleState,
178 VkPipelineFragmentShadingRateStateCreateInfoKHR* shadingRateState,
179 PipelineRenderingCreateInfoWrapper dynamicRenderingState,
180 const VkShaderModule vertShader,
181 const VkShaderModule geomShader,
182 const VkShaderModule fragShader,
183 VkDescriptorSet descriptorSet,
184 VkBuffer vertexBuffer);
185 #ifndef CTS_USES_VULKANSC
186 void beginSecondaryCmdBuffer (VkCommandBuffer cmdBuffer,
189 VkRenderingFlagsKHR renderingFlags = 0u) const;
190 void beginDynamicRender (VkCommandBuffer cmdBuffer,
191 VkImageView srImageView,
192 VkImageLayout srImageLayout,
193 const VkExtent2D& srTexelSize,
194 VkImageView cbImageView,
195 VkImageView dsImageView,
196 const VkClearValue& clearColor,
197 const VkClearValue& clearDepthStencil,
198 VkRenderingFlagsKHR renderingFlags = 0u) const;
199 #endif // CTS_USES_VULKANSC
201 deInt32 PrimIDToPrimitiveShadingRate (deInt32 primID);
202 deInt32 PrimIDToPipelineShadingRate (deInt32 primID);
203 VkExtent2D SanitizeExtent (VkExtent2D ext) const;
204 deInt32 SanitizeRate (deInt32 rate) const;
205 deInt32 ShadingRateExtentToClampedMask (VkExtent2D ext, bool allowSwap) const;
206 deInt32 ShadingRateExtentToEnum (VkExtent2D ext) const;
207 VkExtent2D ShadingRateEnumToExtent (deInt32 rate) const;
208 deInt32 Simulate (deInt32 rate0, deInt32 rate1, deInt32 rate2);
209 VkExtent2D Combine (VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const;
210 bool Force1x1 () const;
213 FSRTestInstance::FSRTestInstance (Context& context, const CaseDef& data)
214 : vkt::TestInstance (context)
216 , m_simulateValueCount (((4 * 4) | 4) + 1)
217 , m_simulateCache (m_simulateValueCount*m_simulateValueCount*m_simulateValueCount, ~0)
218 , m_primIDToPrimitiveShadingRate(NUM_TRIANGLES, ~0)
219 , m_primIDToPipelineShadingRate(NUM_TRIANGLES, ~0)
221 m_supportedFragmentShadingRateCount = 0;
222 m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, DE_NULL);
224 if (m_supportedFragmentShadingRateCount < 3)
225 TCU_THROW(TestError, "*pFragmentShadingRateCount too small");
227 m_supportedFragmentShadingRates.resize(m_supportedFragmentShadingRateCount);
228 for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
230 m_supportedFragmentShadingRates[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
231 m_supportedFragmentShadingRates[i].pNext = nullptr;
233 m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, &m_supportedFragmentShadingRates[0]);
235 m_shadingRateProperties = m_context.getFragmentShadingRateProperties();
238 FSRTestInstance::~FSRTestInstance (void)
242 class FSRTestCase : public TestCase
245 FSRTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data);
247 virtual void initPrograms (SourceCollections& programCollection) const;
248 virtual TestInstance* createInstance (Context& context) const;
249 virtual void checkSupport (Context& context) const;
255 FSRTestCase::FSRTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data)
256 : vkt::TestCase (context, name, desc)
261 FSRTestCase::~FSRTestCase (void)
265 bool FSRTestInstance::Force1x1() const
267 if (m_data.useApiSampleMask && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
270 if (m_data.useSampleMaskIn && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderSampleMask)
273 if (m_data.conservativeEnable && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithConservativeRasterization)
276 if (m_data.useDepthStencil && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderDepthStencilWrites)
279 if (m_data.interlock && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithFragmentShaderInterlock)
282 if (m_data.sampleLocations && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations)
285 if (m_data.sampleShadingEnable || m_data.sampleShadingInput)
291 static VkImageUsageFlags cbUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
292 VK_IMAGE_USAGE_SAMPLED_BIT |
293 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
294 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
296 void FSRTestCase::checkSupport(Context& context) const
298 context.requireDeviceFunctionality("VK_KHR_fragment_shading_rate");
300 if (m_data.groupParams->useDynamicRendering)
301 context.requireDeviceFunctionality("VK_KHR_dynamic_rendering");
303 if (!context.getFragmentShadingRateFeatures().pipelineFragmentShadingRate)
304 TCU_THROW(NotSupportedError, "pipelineFragmentShadingRate not supported");
306 if (m_data.shaderWritesRate &&
307 !context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate)
308 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
310 if (!context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate &&
311 m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
312 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
314 if (!context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
315 m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
316 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
318 const auto& vki = context.getInstanceInterface();
319 const auto physicalDevice = context.getPhysicalDevice();
321 VkImageFormatProperties imageProperties;
322 VkResult result = vki.getPhysicalDeviceImageFormatProperties(physicalDevice, VK_FORMAT_R32G32B32A32_UINT, VK_IMAGE_TYPE_2D,
323 VK_IMAGE_TILING_OPTIMAL, cbUsage, 0, &imageProperties);
325 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
326 TCU_THROW(NotSupportedError, "VK_FORMAT_R32G32B32A32_UINT not supported");
328 if (!(imageProperties.sampleCounts & m_data.samples))
329 TCU_THROW(NotSupportedError, "color buffer sample count not supported");
331 if (m_data.numColorLayers > imageProperties.maxArrayLayers)
332 TCU_THROW(NotSupportedError, "color buffer layers not supported");
334 if (m_data.useAttachment() && !context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
335 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
337 if (!context.getFragmentShadingRateProperties().fragmentShadingRateNonTrivialCombinerOps &&
338 ((m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
339 (m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
340 TCU_THROW(NotSupportedError, "fragmentShadingRateNonTrivialCombinerOps not supported");
342 if (m_data.conservativeEnable)
344 context.requireDeviceFunctionality("VK_EXT_conservative_rasterization");
345 if (m_data.conservativeMode == VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT &&
346 !context.getConservativeRasterizationPropertiesEXT().primitiveUnderestimation)
347 TCU_THROW(NotSupportedError, "primitiveUnderestimation not supported");
350 if (m_data.fragStencil)
351 context.requireDeviceFunctionality("VK_EXT_shader_stencil_export");
353 if (m_data.multiViewport &&
354 !context.getFragmentShadingRateProperties().primitiveFragmentShadingRateWithMultipleViewports)
355 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRateWithMultipleViewports not supported");
357 if (m_data.srLayered &&
358 !context.getFragmentShadingRateProperties().layeredShadingRateAttachments)
359 TCU_THROW(NotSupportedError, "layeredShadingRateAttachments not supported");
361 if ((m_data.multiViewport || m_data.colorLayered) &&
362 !m_data.geometryShader)
363 context.requireDeviceFunctionality("VK_EXT_shader_viewport_index_layer");
365 if (m_data.multiView && m_data.geometryShader &&
366 !context.getMultiviewFeatures().multiviewGeometryShader)
367 TCU_THROW(NotSupportedError, "multiviewGeometryShader not supported");
369 if (m_data.interlock &&
370 !context.getFragmentShaderInterlockFeaturesEXT().fragmentShaderPixelInterlock)
371 TCU_THROW(NotSupportedError, "fragmentShaderPixelInterlock not supported");
373 if (m_data.sampleLocations)
375 context.requireDeviceFunctionality("VK_EXT_sample_locations");
376 if (!(m_data.samples & context.getSampleLocationsPropertiesEXT().sampleLocationSampleCounts))
377 TCU_THROW(NotSupportedError, "samples not supported in sampleLocationSampleCounts");
380 if (m_data.sampleMaskTest && !context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
381 TCU_THROW(NotSupportedError, "fragmentShadingRateWithSampleMask not supported");
383 checkPipelineLibraryRequirements(vki, physicalDevice, m_data.groupParams->pipelineConstructionType);
385 #ifndef CTS_USES_VULKANSC
386 if (m_data.earlyAndLateTest)
388 context.requireDeviceFunctionality("VK_AMD_shader_early_and_late_fragment_tests");
389 if (context.getShaderEarlyAndLateFragmentTestsFeaturesAMD().shaderEarlyAndLateFragmentTests == VK_FALSE)
390 TCU_THROW(NotSupportedError, "shaderEarlyAndLateFragmentTests is not supported");
395 // Error codes writted by the fragment shader
399 ERROR_FRAGCOORD_CENTER = 1,
400 ERROR_VTG_READBACK = 2,
401 ERROR_FRAGCOORD_DERIV = 3,
402 ERROR_FRAGCOORD_IMPLICIT_DERIV = 4,
405 void FSRTestCase::initPrograms (SourceCollections& programCollection) const
407 std::stringstream vss;
410 "#version 450 core\n"
411 "#extension GL_EXT_fragment_shading_rate : enable\n"
412 "#extension GL_ARB_shader_viewport_layer_array : enable\n"
413 "layout(push_constant) uniform PC {\n"
414 " int shadingRate;\n"
416 "layout(location = 0) in vec2 pos;\n"
417 "layout(location = 0) out int instanceIndex;\n"
418 "layout(location = 1) out int readbackok;\n"
419 "layout(location = 2) out float zero;\n"
422 " vec4 gl_Position;\n"
426 " gl_Position = vec4(pos, 0, 1);\n"
427 " instanceIndex = gl_InstanceIndex;\n"
431 if (m_data.shaderWritesRate)
433 vss << " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
435 // Verify that we can read from the output variable
436 vss << " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
438 if (!m_data.geometryShader)
440 if (m_data.multiViewport)
441 vss << " gl_ViewportIndex = instanceIndex & 1;\n";
442 if (m_data.colorLayered)
443 vss << " gl_Layer = (instanceIndex & 2) >> 1;\n";
449 programCollection.glslSources.add("vert") << glu::VertexSource(vss.str());
451 if (m_data.geometryShader)
453 std::string writeShadingRate = "";
454 if (m_data.shaderWritesRate)
457 " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n"
458 " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
460 if (m_data.multiViewport)
461 writeShadingRate += " gl_ViewportIndex = inInstanceIndex[0] & 1;\n";
463 if (m_data.colorLayered)
464 writeShadingRate += " gl_Layer = (inInstanceIndex[0] & 2) >> 1;\n";
467 std::stringstream gss;
469 "#version 450 core\n"
470 "#extension GL_EXT_fragment_shading_rate : enable\n"
472 "layout(push_constant) uniform PC {\n"
473 " int shadingRate;\n"
478 " vec4 gl_Position;\n"
481 "layout(location = 0) in int inInstanceIndex[];\n"
482 "layout(location = 0) out int outInstanceIndex;\n"
483 "layout(location = 1) out int readbackok;\n"
484 "layout(location = 2) out float zero;\n"
485 "layout(triangles) in;\n"
486 "layout(triangle_strip, max_vertices=3) out;\n"
488 "out gl_PerVertex {\n"
489 " vec4 gl_Position;\n"
494 " gl_Position = gl_in[0].gl_Position;\n"
495 " outInstanceIndex = inInstanceIndex[0];\n"
498 << writeShadingRate <<
501 " gl_Position = gl_in[1].gl_Position;\n"
502 " outInstanceIndex = inInstanceIndex[1];\n"
505 << writeShadingRate <<
508 " gl_Position = gl_in[2].gl_Position;\n"
509 " outInstanceIndex = inInstanceIndex[2];\n"
512 << writeShadingRate <<
516 programCollection.glslSources.add("geom") << glu::GeometrySource(gss.str());
519 std::stringstream fss;
522 "#version 450 core\n"
523 "#extension GL_EXT_fragment_shading_rate : enable\n"
524 "#extension GL_ARB_shader_stencil_export : enable\n"
525 "#extension GL_ARB_fragment_shader_interlock : enable\n";
527 if (m_data.earlyAndLateTest)
528 fss << "#extension GL_AMD_shader_early_and_late_fragment_tests : enable\n";
530 fss << "layout(location = 0) out uvec4 col0;\n"
531 "layout(set = 0, binding = 0) buffer Block { uint counter; } buf;\n"
532 "layout(set = 0, binding = 3) uniform usampler2D tex;\n"
533 "layout(location = 0) flat in int instanceIndex;\n"
534 "layout(location = 1) flat in int readbackok;\n"
535 "layout(location = 2) " << (m_data.sampleShadingInput ? "sample " : "") << "in float zero;\n";
537 if (m_data.earlyAndLateTest)
538 fss << "layout(early_and_late_fragment_tests_amd) in;\n";
540 if (m_data.fragDepth && m_data.earlyAndLateTest)
541 fss << "layout(depth_less) out float gl_FragDepth;\n";
543 if (m_data.fragStencil && m_data.earlyAndLateTest)
544 fss << "layout(stencil_ref_less_front_amd) out int gl_FragStencilRefARB;\n";
546 if (m_data.interlock)
547 fss << "layout(pixel_interlock_ordered) in;\n";
553 if (m_data.interlock)
554 fss << " beginInvocationInterlockARB();\n";
557 // X component gets shading rate enum
558 " col0.x = gl_ShadingRateEXT;\n"
560 // Z component gets packed primitiveID | atomic value
561 " col0.z = (instanceIndex << 24) | ((atomicAdd(buf.counter, 1) + 1) & 0x00FFFFFFu);\n"
562 " ivec2 fragCoordXY = ivec2(gl_FragCoord.xy);\n"
563 " ivec2 fragSize = ivec2(1<<((gl_ShadingRateEXT/4)&3), 1<<(gl_ShadingRateEXT&3));\n"
564 // W component gets error code
565 " col0.w = uint(zero)" << (m_data.sampleShadingInput ? " * gl_SampleID" : "") << ";\n"
566 " if (((fragCoordXY - fragSize / 2) % fragSize) != ivec2(0,0))\n"
567 " col0.w = " << ERROR_FRAGCOORD_CENTER << ";\n";
569 if (m_data.shaderWritesRate)
572 " if (readbackok != 1)\n"
573 " col0.w = " << ERROR_VTG_READBACK << ";\n";
576 // When sample shading, gl_FragCoord is more likely to give bad derivatives,
577 // e.g. due to a partially covered quad having some pixels center sample and
578 // some sample at a sample location.
579 if (!m_data.sampleShadingEnable && !m_data.sampleShadingInput)
581 fss << " if (dFdx(gl_FragCoord.xy) != ivec2(fragSize.x, 0) || dFdy(gl_FragCoord.xy) != ivec2(0, fragSize.y))\n"
582 " col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (int(dFdx(gl_FragCoord.xy)) << 14) | (int(dFdx(gl_FragCoord.xy)) << 8) | " << ERROR_FRAGCOORD_DERIV << ";\n";
584 fss << " uint implicitDerivX = texture(tex, vec2(gl_FragCoord.x / textureSize(tex, 0).x, 0)).x;\n"
585 " uint implicitDerivY = texture(tex, vec2(0, gl_FragCoord.y / textureSize(tex, 0).y)).x;\n"
586 " if (implicitDerivX != fragSize.x || implicitDerivY != fragSize.y)\n"
587 " col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (implicitDerivY << 14) | (implicitDerivX << 8) | " << ERROR_FRAGCOORD_IMPLICIT_DERIV << ";\n";
589 // Y component gets sample mask value
590 if (m_data.useSampleMaskIn)
591 fss << " col0.y = gl_SampleMaskIn[0];\n";
593 if (m_data.fragDepth)
594 fss << " gl_FragDepth = float(instanceIndex) / float(" << NUM_TRIANGLES << ");\n";
596 if (m_data.fragStencil)
597 fss << " gl_FragStencilRefARB = instanceIndex;\n";
599 if (m_data.interlock)
600 fss << " endInvocationInterlockARB();\n";
605 programCollection.glslSources.add("frag") << glu::FragmentSource(fss.str());
607 std::stringstream css;
609 std::string fsampType = m_data.samples > 1 ? "texture2DMSArray" : "texture2DArray";
610 std::string usampType = m_data.samples > 1 ? "utexture2DMSArray" : "utexture2DArray";
612 // Compute shader copies color/depth/stencil to linear layout in buffer memory
614 "#version 450 core\n"
615 "#extension GL_EXT_samplerless_texture_functions : enable\n"
616 "layout(set = 0, binding = 1) uniform " << usampType << " colorTex;\n"
617 "layout(set = 0, binding = 2, std430) buffer Block0 { uvec4 b[]; } colorbuf;\n"
618 "layout(set = 0, binding = 4, std430) buffer Block1 { float b[]; } depthbuf;\n"
619 "layout(set = 0, binding = 5, std430) buffer Block2 { uint b[]; } stencilbuf;\n"
620 "layout(set = 0, binding = 6) uniform " << fsampType << " depthTex;\n"
621 "layout(set = 0, binding = 7) uniform " << usampType << " stencilTex;\n"
622 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
625 " for (int i = 0; i < " << m_data.samples << "; ++i) {\n"
626 " uint idx = ((gl_GlobalInvocationID.z * " << m_data.framebufferDim.height << " + gl_GlobalInvocationID.y) * " << m_data.framebufferDim.width << " + gl_GlobalInvocationID.x) * " << m_data.samples << " + i;\n"
627 " colorbuf.b[idx] = texelFetch(colorTex, ivec3(gl_GlobalInvocationID.xyz), i);\n";
629 if (m_data.fragDepth)
630 css << " depthbuf.b[idx] = texelFetch(depthTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
632 if (m_data.fragStencil)
633 css << " stencilbuf.b[idx] = texelFetch(stencilTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
639 programCollection.glslSources.add("comp") << glu::ComputeSource(css.str());
642 TestInstance* FSRTestCase::createInstance (Context& context) const
644 return new FSRTestInstance(context, m_data);
647 deInt32 FSRTestInstance::ShadingRateExtentToEnum(VkExtent2D ext) const
649 ext.width = deCtz32(ext.width);
650 ext.height = deCtz32(ext.height);
652 return (ext.width << 2) | ext.height;
655 VkExtent2D FSRTestInstance::ShadingRateEnumToExtent(deInt32 rate) const
658 ret.width = 1 << ((rate/4) & 3);
659 ret.height = 1 << (rate & 3);
664 VkExtent2D FSRTestInstance::Combine(VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const
672 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
674 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR:
676 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR:
677 ret = { de::min(ext0.width, ext1.width), de::min(ext0.height, ext1.height) };
679 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR:
680 ret = { de::max(ext0.width, ext1.width), de::max(ext0.height, ext1.height) };
682 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR:
683 ret = { ext0.width * ext1.width, ext0.height * ext1.height };
684 if (!m_shadingRateProperties.fragmentShadingRateStrictMultiplyCombiner)
686 if (ext0.width == 1 && ext1.width == 1)
688 if (ext0.height == 1 && ext1.height == 1)
695 deInt32 FSRTestInstance::Simulate(deInt32 rate0, deInt32 rate1, deInt32 rate2)
697 deInt32 &cachedRate = m_simulateCache[(rate2*m_simulateValueCount + rate1)*m_simulateValueCount + rate0];
698 if (cachedRate != ~0)
701 VkExtent2D extent0 = ShadingRateEnumToExtent(rate0);
702 VkExtent2D extent1 = ShadingRateEnumToExtent(rate1);
703 VkExtent2D extent2 = ShadingRateEnumToExtent(rate2);
705 deInt32 finalMask = 0;
706 // Simulate once for implementations that don't allow swapping rate xy,
707 // and once for those that do. Any of those results is allowed.
708 for (deUint32 allowSwap = 0; allowSwap <= 1; ++allowSwap)
710 // Combine rate 0 and 1, get a mask of possible clamped rates
711 VkExtent2D intermed = Combine(extent0, extent1, m_data.combinerOp[0]);
712 deInt32 intermedMask = ShadingRateExtentToClampedMask(intermed, allowSwap == 1);
714 // For each clamped rate, combine that with rate 2 and accumulate the possible clamped rates
715 for (int i = 0; i < 16; ++i)
717 if (intermedMask & (1<<i))
719 VkExtent2D final = Combine(ShadingRateEnumToExtent(i), extent2, m_data.combinerOp[1]);
720 finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
724 // unclamped intermediate value is also permitted
725 VkExtent2D final = Combine(intermed, extent2, m_data.combinerOp[1]);
726 finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
733 cachedRate = finalMask;
737 // If a rate is not valid (<=4x4), clamp it to something valid.
738 // This is only used for "inputs" to the system, not to mimic
739 // how the implementation internally clamps intermediate values.
740 VkExtent2D FSRTestInstance::SanitizeExtent(VkExtent2D ext) const
742 DE_ASSERT(ext.width > 0 && ext.height > 0);
744 ext.width = de::min(ext.width, 4u);
745 ext.height = de::min(ext.height, 4u);
750 // Map an extent to a mask of all modes smaller than or equal to it in either dimension
751 deInt32 FSRTestInstance::ShadingRateExtentToClampedMask(VkExtent2D ext, bool allowSwap) const
753 deUint32 desiredSize = ext.width * ext.height;
757 while (desiredSize > 0)
759 // First, find modes that maximize the area
760 for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
762 const VkPhysicalDeviceFragmentShadingRateKHR &supportedRate = m_supportedFragmentShadingRates[i];
763 if ((supportedRate.sampleCounts & m_data.samples) &&
764 supportedRate.fragmentSize.width * supportedRate.fragmentSize.height == desiredSize &&
765 ((supportedRate.fragmentSize.width <= ext.width && supportedRate.fragmentSize.height <= ext.height) ||
766 (supportedRate.fragmentSize.height <= ext.width && supportedRate.fragmentSize.width <= ext.height && allowSwap)))
768 mask |= 1 << ShadingRateExtentToEnum(supportedRate.fragmentSize);
773 // Amongst the modes that maximize the area, pick the ones that
774 // minimize the aspect ratio. Prefer ratio of 1, then 2, then 4.
775 // 1x1 = 0, 2x2 = 5, 4x4 = 10
776 static const deUint32 aspectMaskRatio1 = 0x421;
777 // 2x1 = 4, 1x2 = 1, 4x2 = 9, 2x4 = 6
778 static const deUint32 aspectMaskRatio2 = 0x252;
780 static const deUint32 aspectMaskRatio4 = 0x104;
782 if (mask & aspectMaskRatio1)
784 mask &= aspectMaskRatio1;
787 if (mask & aspectMaskRatio2)
789 mask &= aspectMaskRatio2;
792 if (mask & aspectMaskRatio4)
794 mask &= aspectMaskRatio4;
806 deInt32 FSRTestInstance::SanitizeRate(deInt32 rate) const
808 VkExtent2D extent = ShadingRateEnumToExtent(rate);
810 extent = SanitizeExtent(extent);
812 return ShadingRateExtentToEnum(extent);
815 // Map primID % 9 to primitive shading rate
816 deInt32 FSRTestInstance::PrimIDToPrimitiveShadingRate(deInt32 primID)
818 deInt32 &cachedRate = m_primIDToPrimitiveShadingRate[primID];
819 if (cachedRate != ~0)
823 extent.width = 1 << (primID % 3);
824 extent.height = 1 << ((primID/3) % 3);
826 cachedRate = ShadingRateExtentToEnum(extent);
830 // Map primID / 9 to pipeline shading rate
831 deInt32 FSRTestInstance::PrimIDToPipelineShadingRate(deInt32 primID)
833 deInt32 &cachedRate = m_primIDToPipelineShadingRate[primID];
834 if (cachedRate != ~0)
839 extent.width = 1 << (primID % 3);
840 extent.height = 1 << ((primID/3) % 3);
842 cachedRate = ShadingRateExtentToEnum(extent);
846 static de::MovePtr<BufferWithMemory> CreateCachedBuffer(const vk::DeviceInterface& vk,
847 const vk::VkDevice device,
848 vk::Allocator& allocator,
849 const vk::VkBufferCreateInfo& bufferCreateInfo)
853 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
854 vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible | MemoryRequirement::Cached));
856 catch (const tcu::NotSupportedError&)
858 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
859 vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible));
863 tcu::TestStatus FSRTestInstance::iterate (void)
865 const DeviceInterface& vk = m_context.getDeviceInterface();
866 const VkDevice device = m_context.getDevice();
867 tcu::TestLog& log = m_context.getTestContext().getLog();
868 Allocator& allocator = m_context.getDefaultAllocator();
869 VkFlags allShaderStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
870 VkFlags allPipelineStages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
871 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
872 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
873 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
874 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
875 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
876 VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
877 const VkFormat cbFormat = VK_FORMAT_R32G32B32A32_UINT;
878 VkFormat dsFormat = VK_FORMAT_UNDEFINED;
880 if (m_data.geometryShader)
882 allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
883 allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
886 if (m_data.useDepthStencil)
888 VkFormatProperties formatProps;
889 m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProps);
890 if (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
892 dsFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
896 dsFormat = VK_FORMAT_D24_UNORM_S8_UINT;
901 deRandom_init(&rnd, m_data.seed);
903 qpTestResult res = QP_TEST_RESULT_PASS;
904 deUint32 numUnexpected1x1Samples = 0;
905 deUint32 numTotalSamples = 0;
909 ATTACHMENT_MODE_DEFAULT = 0,
910 ATTACHMENT_MODE_LAYOUT_OPTIMAL,
911 ATTACHMENT_MODE_IMAGELESS,
912 ATTACHMENT_MODE_2DARRAY,
913 ATTACHMENT_MODE_TILING_LINEAR,
915 ATTACHMENT_MODE_COUNT,
918 deUint32 numSRLayers = m_data.srLayered ? 2u : 1u;
920 VkExtent2D minFragmentShadingRateAttachmentTexelSize = {1, 1};
921 VkExtent2D maxFragmentShadingRateAttachmentTexelSize = {1, 1};
922 deUint32 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = 1;
923 if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
925 minFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().minFragmentShadingRateAttachmentTexelSize;
926 maxFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSize;
927 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
930 VkDeviceSize atomicBufferSize = sizeof(deUint32);
932 de::MovePtr<BufferWithMemory> atomicBuffer;
933 atomicBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
934 vk, device, allocator, makeBufferCreateInfo(atomicBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
936 deUint32 *abuf = (deUint32 *)atomicBuffer->getAllocation().getHostPtr();
938 // NUM_TRIANGLES triangles, 3 vertices, 2 components of float position
939 VkDeviceSize vertexBufferSize = NUM_TRIANGLES * 3 * 2 * sizeof(float);
941 de::MovePtr<BufferWithMemory> vertexBuffer;
942 vertexBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
943 vk, device, allocator, makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
945 float *vbuf = (float *)vertexBuffer->getAllocation().getHostPtr();
946 for (deInt32 i = 0; i < (deInt32)(vertexBufferSize / sizeof(float)); ++i)
948 vbuf[i] = deRandom_getFloat(&rnd)*2.0f - 1.0f;
950 flushAlloc(vk, device, vertexBuffer->getAllocation());
952 VkDeviceSize colorOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * 4 * sizeof(deUint32) * m_data.numColorLayers;
953 de::MovePtr<BufferWithMemory> colorOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(colorOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
955 VkDeviceSize depthOutputBufferSize = 0, stencilOutputBufferSize = 0;
956 de::MovePtr<BufferWithMemory> depthOutputBuffer, stencilOutputBuffer;
957 if (m_data.useDepthStencil)
959 depthOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(float) * m_data.numColorLayers;
960 depthOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(depthOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
962 stencilOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(deUint32) * m_data.numColorLayers;
963 stencilOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(stencilOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
966 deUint32 minSRTexelWidth = minFragmentShadingRateAttachmentTexelSize.width;
967 deUint32 minSRTexelHeight = minFragmentShadingRateAttachmentTexelSize.height;
968 deUint32 maxSRWidth = (m_data.framebufferDim.width + minSRTexelWidth - 1) / minSRTexelWidth;
969 deUint32 maxSRHeight = (m_data.framebufferDim.height + minSRTexelHeight - 1) / minSRTexelHeight;
971 // max size over all formats
972 VkDeviceSize srFillBufferSize = numSRLayers * maxSRWidth * maxSRHeight * 32/*4 component 64-bit*/;
973 de::MovePtr<BufferWithMemory> srFillBuffer;
974 deUint8 *fillPtr = DE_NULL;
975 if (m_data.useAttachment())
977 srFillBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(srFillBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
978 fillPtr = (deUint8 *)srFillBuffer->getAllocation().getHostPtr();
981 de::MovePtr<ImageWithMemory> cbImage;
982 Move<VkImageView> cbImageView;
984 const VkImageCreateInfo imageCreateInfo =
986 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
987 DE_NULL, // const void* pNext;
988 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
989 VK_IMAGE_TYPE_2D, // VkImageType imageType;
990 cbFormat, // VkFormat format;
992 m_data.framebufferDim.width, // deUint32 width;
993 m_data.framebufferDim.height, // deUint32 height;
994 1u // deUint32 depth;
995 }, // VkExtent3D extent;
996 1u, // deUint32 mipLevels;
997 m_data.numColorLayers, // deUint32 arrayLayers;
998 m_data.samples, // VkSampleCountFlagBits samples;
999 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1000 cbUsage, // VkImageUsageFlags usage;
1001 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1002 0u, // deUint32 queueFamilyIndexCount;
1003 DE_NULL, // const deUint32* pQueueFamilyIndices;
1004 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1006 cbImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1007 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1009 VkImageViewCreateInfo imageViewCreateInfo =
1011 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1012 DE_NULL, // const void* pNext;
1013 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1014 **cbImage, // VkImage image;
1015 VK_IMAGE_VIEW_TYPE_2D_ARRAY, // VkImageViewType viewType;
1016 cbFormat, // VkFormat format;
1018 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1019 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1020 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1021 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1022 }, // VkComponentMapping components;
1024 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1025 0u, // deUint32 baseMipLevel;
1026 1u, // deUint32 levelCount;
1027 0u, // deUint32 baseArrayLayer;
1028 m_data.numColorLayers // deUint32 layerCount;
1029 } // VkImageSubresourceRange subresourceRange;
1031 cbImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1034 de::MovePtr<ImageWithMemory> dsImage;
1035 Move<VkImageView> dsImageView, dImageView, sImageView;
1036 VkImageUsageFlags dsUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
1037 VK_IMAGE_USAGE_SAMPLED_BIT |
1038 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1039 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1040 if (m_data.useDepthStencil)
1042 const VkImageCreateInfo imageCreateInfo =
1044 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1045 DE_NULL, // const void* pNext;
1046 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1047 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1048 dsFormat, // VkFormat format;
1050 m_data.framebufferDim.width, // deUint32 width;
1051 m_data.framebufferDim.height, // deUint32 height;
1052 1u // deUint32 depth;
1053 }, // VkExtent3D extent;
1054 1u, // deUint32 mipLevels;
1055 m_data.numColorLayers, // deUint32 arrayLayers;
1056 m_data.samples, // VkSampleCountFlagBits samples;
1057 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1058 dsUsage, // VkImageUsageFlags usage;
1059 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1060 0u, // deUint32 queueFamilyIndexCount;
1061 DE_NULL, // const deUint32* pQueueFamilyIndices;
1062 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1064 dsImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1065 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1067 VkImageViewCreateInfo imageViewCreateInfo =
1069 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1070 DE_NULL, // const void* pNext;
1071 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1072 **dsImage, // VkImage image;
1073 VK_IMAGE_VIEW_TYPE_2D_ARRAY, // VkImageViewType viewType;
1074 dsFormat, // VkFormat format;
1076 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1077 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1078 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1079 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1080 }, // VkComponentMapping components;
1082 VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
1083 0u, // deUint32 baseMipLevel;
1084 1u, // deUint32 levelCount;
1085 0u, // deUint32 baseArrayLayer;
1086 m_data.numColorLayers // deUint32 layerCount;
1087 } // VkImageSubresourceRange subresourceRange;
1089 dsImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1090 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1091 dImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1092 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1093 sImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1096 // Image used to test implicit derivative calculations.
1097 // Filled with a value of 1<<lod.
1098 de::MovePtr<ImageWithMemory> derivImage;
1099 Move<VkImageView> derivImageView;
1100 VkImageUsageFlags derivUsage = VK_IMAGE_USAGE_SAMPLED_BIT |
1101 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1102 deUint32 derivNumLevels;
1104 deUint32 maxDim = de::max(m_context.getFragmentShadingRateProperties().maxFragmentSize.width, m_context.getFragmentShadingRateProperties().maxFragmentSize.height);
1105 derivNumLevels = 1 + deCtz32(maxDim);
1106 const VkImageCreateInfo imageCreateInfo =
1108 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1109 DE_NULL, // const void* pNext;
1110 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1111 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1112 VK_FORMAT_R32_UINT, // VkFormat format;
1114 m_context.getFragmentShadingRateProperties().maxFragmentSize.width, // deUint32 width;
1115 m_context.getFragmentShadingRateProperties().maxFragmentSize.height, // deUint32 height;
1116 1u // deUint32 depth;
1117 }, // VkExtent3D extent;
1118 derivNumLevels, // deUint32 mipLevels;
1119 1u, // deUint32 arrayLayers;
1120 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1121 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1122 derivUsage, // VkImageUsageFlags usage;
1123 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1124 0u, // deUint32 queueFamilyIndexCount;
1125 DE_NULL, // const deUint32* pQueueFamilyIndices;
1126 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1128 derivImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1129 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1131 VkImageViewCreateInfo imageViewCreateInfo =
1133 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1134 DE_NULL, // const void* pNext;
1135 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1136 **derivImage, // VkImage image;
1137 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1138 VK_FORMAT_R32_UINT, // VkFormat format;
1140 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1141 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1142 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1143 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1144 }, // VkComponentMapping components;
1146 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1147 0u, // deUint32 baseMipLevel;
1148 derivNumLevels, // deUint32 levelCount;
1149 0u, // deUint32 baseArrayLayer;
1150 1u // deUint32 layerCount;
1151 } // VkImageSubresourceRange subresourceRange;
1153 derivImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1156 // sampler used with derivImage
1157 const struct VkSamplerCreateInfo samplerInfo =
1159 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // sType
1162 VK_FILTER_NEAREST, // magFilter
1163 VK_FILTER_NEAREST, // minFilter
1164 VK_SAMPLER_MIPMAP_MODE_NEAREST, // mipmapMode
1165 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeU
1166 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeV
1167 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeW
1169 VK_FALSE, // anisotropyEnable
1170 1.0f, // maxAnisotropy
1171 DE_FALSE, // compareEnable
1172 VK_COMPARE_OP_ALWAYS, // compareOp
1174 (float)derivNumLevels, // maxLod
1175 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, // borderColor
1176 VK_FALSE, // unnormalizedCoords
1179 Move<VkSampler> sampler = createSampler(vk, device, &samplerInfo);
1181 Move<vk::VkDescriptorSetLayout> descriptorSetLayout;
1182 VkDescriptorSetLayoutCreateFlags layoutCreateFlags = 0;
1184 const VkDescriptorSetLayoutBinding bindings[] =
1188 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1189 1u, // descriptorCount
1190 allShaderStages, // stageFlags
1191 DE_NULL, // pImmutableSamplers
1195 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1196 1u, // descriptorCount
1197 allShaderStages, // stageFlags
1198 DE_NULL, // pImmutableSamplers
1202 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1203 1u, // descriptorCount
1204 allShaderStages, // stageFlags
1205 DE_NULL, // pImmutableSamplers
1209 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // descriptorType
1210 1u, // descriptorCount
1211 allShaderStages, // stageFlags
1212 DE_NULL, // pImmutableSamplers
1216 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1217 1u, // descriptorCount
1218 allShaderStages, // stageFlags
1219 DE_NULL, // pImmutableSamplers
1223 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1224 1u, // descriptorCount
1225 allShaderStages, // stageFlags
1226 DE_NULL, // pImmutableSamplers
1230 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1231 1u, // descriptorCount
1232 allShaderStages, // stageFlags
1233 DE_NULL, // pImmutableSamplers
1237 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1238 1u, // descriptorCount
1239 allShaderStages, // stageFlags
1240 DE_NULL, // pImmutableSamplers
1244 // Create a layout and allocate a descriptor set for it.
1245 const VkDescriptorSetLayoutCreateInfo setLayoutCreateInfo =
1247 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
1249 layoutCreateFlags, // flags
1250 sizeof(bindings)/sizeof(bindings[0]), // bindingCount
1251 &bindings[0] // pBindings
1254 descriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo);
1256 const VkPushConstantRange pushConstantRange =
1258 allShaderStages, // VkShaderStageFlags stageFlags;
1259 0u, // deUint32 offset;
1260 sizeof(deInt32) // deUint32 size;
1263 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1265 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
1267 (VkPipelineLayoutCreateFlags)0,
1268 1, // setLayoutCount
1269 &descriptorSetLayout.get(), // pSetLayouts
1270 1u, // pushConstantRangeCount
1271 &pushConstantRange, // pPushConstantRanges
1274 Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo, NULL);
1276 const Unique<VkShaderModule> cs (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
1278 const VkPipelineShaderStageCreateInfo csShaderCreateInfo =
1280 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1282 (VkPipelineShaderStageCreateFlags)0,
1283 VK_SHADER_STAGE_COMPUTE_BIT, // stage
1286 DE_NULL, // pSpecializationInfo
1289 const VkComputePipelineCreateInfo pipelineCreateInfo =
1291 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1294 csShaderCreateInfo, // cs
1295 *pipelineLayout, // layout
1296 (vk::VkPipeline)0, // basePipelineHandle
1297 0u, // basePipelineIndex
1299 Move<VkPipeline> computePipeline = createComputePipeline(vk, device, DE_NULL, &pipelineCreateInfo, NULL);
1301 for (deUint32 modeIdx = 0; modeIdx < ATTACHMENT_MODE_COUNT; ++modeIdx)
1303 // If we're not using an attachment, don't test all the different attachment modes
1304 if (modeIdx != ATTACHMENT_MODE_DEFAULT && !m_data.useAttachment())
1307 // Consider all uint formats possible
1308 static const VkFormat srFillFormats[] =
1311 VK_FORMAT_R8G8_UINT,
1312 VK_FORMAT_R8G8B8_UINT,
1313 VK_FORMAT_R8G8B8A8_UINT,
1315 VK_FORMAT_R16G16_UINT,
1316 VK_FORMAT_R16G16B16_UINT,
1317 VK_FORMAT_R16G16B16A16_UINT,
1319 VK_FORMAT_R32G32_UINT,
1320 VK_FORMAT_R32G32B32_UINT,
1321 VK_FORMAT_R32G32B32A32_UINT,
1323 VK_FORMAT_R64G64_UINT,
1324 VK_FORMAT_R64G64B64_UINT,
1325 VK_FORMAT_R64G64B64A64_UINT,
1327 // Only test all formats in the default mode
1328 deUint32 numFillFormats = modeIdx == ATTACHMENT_MODE_DEFAULT ? (deUint32)(sizeof(srFillFormats)/sizeof(srFillFormats[0])) : 1u;
1330 // Iterate over all supported tile sizes and formats
1331 for (deUint32 srTexelWidth = minFragmentShadingRateAttachmentTexelSize.width;
1332 srTexelWidth <= maxFragmentShadingRateAttachmentTexelSize.width;
1334 for (deUint32 srTexelHeight = minFragmentShadingRateAttachmentTexelSize.height;
1335 srTexelHeight <= maxFragmentShadingRateAttachmentTexelSize.height;
1337 for (deUint32 formatIdx = 0; formatIdx < numFillFormats; ++formatIdx)
1339 deUint32 aspectRatio = (srTexelHeight > srTexelWidth) ? (srTexelHeight / srTexelWidth) : (srTexelWidth / srTexelHeight);
1340 if (aspectRatio > maxFragmentShadingRateAttachmentTexelSizeAspectRatio)
1343 // Go through the loop only once when not using an attachment
1344 if (!m_data.useAttachment() &&
1345 (srTexelWidth != minFragmentShadingRateAttachmentTexelSize.width ||
1346 srTexelHeight != minFragmentShadingRateAttachmentTexelSize.height ||
1350 bool imagelessFB = modeIdx == ATTACHMENT_MODE_IMAGELESS;
1352 deUint32 srWidth = (m_data.framebufferDim.width + srTexelWidth - 1) / srTexelWidth;
1353 deUint32 srHeight = (m_data.framebufferDim.height + srTexelHeight - 1) / srTexelHeight;
1355 VkFormat srFormat = srFillFormats[formatIdx];
1356 deUint32 srFillBpp = tcu::getPixelSize(mapVkFormat(srFormat));
1358 VkImageLayout srLayout = modeIdx == ATTACHMENT_MODE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR : VK_IMAGE_LAYOUT_GENERAL;
1359 VkImageViewType srViewType = modeIdx == ATTACHMENT_MODE_2DARRAY ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
1360 VkImageTiling srTiling = (modeIdx == ATTACHMENT_MODE_TILING_LINEAR) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
1362 VkFormatProperties srFormatProperties;
1363 m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), srFormat, &srFormatProperties);
1364 VkFormatFeatureFlags srFormatFeatures = srTiling == VK_IMAGE_TILING_LINEAR ? srFormatProperties.linearTilingFeatures : srFormatProperties.optimalTilingFeatures;
1366 if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
1367 !(srFormatFeatures & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR))
1369 if (srFormat == VK_FORMAT_R8_UINT && srTiling == VK_IMAGE_TILING_OPTIMAL)
1371 log << tcu::TestLog::Message << "VK_FORMAT_R8_UINT/VK_IMAGE_TILING_OPTIMAL don't support VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" << tcu::TestLog::EndMessage;
1372 res = QP_TEST_RESULT_FAIL;
1377 Move<vk::VkDescriptorPool> descriptorPool;
1378 Move<vk::VkDescriptorSet> descriptorSet;
1379 VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
1381 vk::DescriptorPoolBuilder poolBuilder;
1382 for (deInt32 i = 0; i < (deInt32)(sizeof(bindings)/sizeof(bindings[0])); ++i)
1383 poolBuilder.addType(bindings[i].descriptorType, bindings[i].descriptorCount);
1385 descriptorPool = poolBuilder.build(vk, device, poolCreateFlags, 1u);
1386 descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
1388 de::MovePtr<ImageWithMemory> srImage;
1389 Move<VkImageView> srImageView;
1390 VkImageUsageFlags srUsage = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR |
1391 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
1392 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1394 if (m_data.useAttachment())
1396 const VkImageCreateInfo imageCreateInfo =
1398 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1399 DE_NULL, // const void* pNext;
1400 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1401 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1402 srFormat, // VkFormat format;
1404 srWidth, // deUint32 width;
1405 srHeight, // deUint32 height;
1406 1u // deUint32 depth;
1407 }, // VkExtent3D extent;
1408 1u, // deUint32 mipLevels;
1409 numSRLayers, // deUint32 arrayLayers;
1410 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1411 srTiling, // VkImageTiling tiling;
1412 srUsage, // VkImageUsageFlags usage;
1413 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1414 0u, // deUint32 queueFamilyIndexCount;
1415 DE_NULL, // const deUint32* pQueueFamilyIndices;
1416 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1418 srImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1419 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1421 VkImageViewCreateInfo imageViewCreateInfo =
1423 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1424 DE_NULL, // const void* pNext;
1425 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1426 **srImage, // VkImage image;
1427 srViewType, // VkImageViewType viewType;
1428 srFormat, // VkFormat format;
1430 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1431 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1432 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1433 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1434 }, // VkComponentMapping components;
1436 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1437 0u, // deUint32 baseMipLevel;
1438 1u, // deUint32 levelCount;
1439 0u, // deUint32 baseArrayLayer;
1440 srViewType == VK_IMAGE_VIEW_TYPE_2D ?
1441 1 : numSRLayers, // deUint32 layerCount;
1442 } // VkImageSubresourceRange subresourceRange;
1444 srImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1447 VkDescriptorImageInfo imageInfo;
1448 VkDescriptorBufferInfo bufferInfo;
1450 VkWriteDescriptorSet w =
1452 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
1454 *descriptorSet, // dstSet
1455 (deUint32)0, // dstBinding
1456 0, // dstArrayElement
1457 1u, // descriptorCount
1458 bindings[0].descriptorType, // descriptorType
1459 &imageInfo, // pImageInfo
1460 &bufferInfo, // pBufferInfo
1461 DE_NULL, // pTexelBufferView
1465 flushAlloc(vk, device, atomicBuffer->getAllocation());
1467 bufferInfo = makeDescriptorBufferInfo(**atomicBuffer, 0, atomicBufferSize);
1469 w.descriptorType = bindings[0].descriptorType;
1470 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1472 imageInfo = makeDescriptorImageInfo(DE_NULL, *cbImageView, VK_IMAGE_LAYOUT_GENERAL);
1474 w.descriptorType = bindings[1].descriptorType;
1475 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1477 bufferInfo = makeDescriptorBufferInfo(**colorOutputBuffer, 0, colorOutputBufferSize);
1479 w.descriptorType = bindings[2].descriptorType;
1480 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1482 imageInfo = makeDescriptorImageInfo(*sampler, *derivImageView, VK_IMAGE_LAYOUT_GENERAL);
1484 w.descriptorType = bindings[3].descriptorType;
1485 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1487 if (m_data.useDepthStencil)
1489 bufferInfo = makeDescriptorBufferInfo(**depthOutputBuffer, 0, depthOutputBufferSize);
1491 w.descriptorType = bindings[4].descriptorType;
1492 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1494 bufferInfo = makeDescriptorBufferInfo(**stencilOutputBuffer, 0, stencilOutputBufferSize);
1496 w.descriptorType = bindings[5].descriptorType;
1497 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1499 imageInfo = makeDescriptorImageInfo(DE_NULL, *dImageView, VK_IMAGE_LAYOUT_GENERAL);
1501 w.descriptorType = bindings[6].descriptorType;
1502 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1504 imageInfo = makeDescriptorImageInfo(DE_NULL, *sImageView, VK_IMAGE_LAYOUT_GENERAL);
1506 w.descriptorType = bindings[7].descriptorType;
1507 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1510 Move<VkRenderPass> renderPass;
1511 Move<VkFramebuffer> framebuffer;
1513 std::vector<VkImageView> attachments;
1514 attachments.push_back(*cbImageView);
1515 deUint32 dsAttachmentIdx = 0, srAttachmentIdx = 0;
1516 if (m_data.useAttachment())
1518 srAttachmentIdx = (deUint32)attachments.size();
1519 attachments.push_back(*srImageView);
1521 if (m_data.useDepthStencil)
1523 dsAttachmentIdx = (deUint32)attachments.size();
1524 attachments.push_back(*dsImageView);
1527 if (!m_data.groupParams->useDynamicRendering)
1529 const vk::VkAttachmentReference2 colorAttachmentReference
1531 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1534 vk::VK_IMAGE_LAYOUT_GENERAL, // layout
1538 const vk::VkAttachmentReference2 fragmentShadingRateAttachment =
1540 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1542 srAttachmentIdx, // attachment
1547 const vk::VkAttachmentReference2 depthAttachmentReference =
1549 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1551 dsAttachmentIdx, // attachment
1552 vk::VK_IMAGE_LAYOUT_GENERAL, // layout
1556 const bool noAttachmentPtr = (m_data.attachmentUsage == AttachmentUsage::NO_ATTACHMENT_PTR);
1557 const VkFragmentShadingRateAttachmentInfoKHR shadingRateAttachmentInfo =
1559 VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, // VkStructureType sType;
1560 DE_NULL, // const void* pNext;
1561 (noAttachmentPtr ? nullptr : &fragmentShadingRateAttachment), // const VkAttachmentReference2* pFragmentShadingRateAttachment;
1562 { srTexelWidth, srTexelHeight }, // VkExtent2D shadingRateAttachmentTexelSize;
1565 const bool useAttachmentInfo = (m_data.attachmentUsage != AttachmentUsage::NO_ATTACHMENT);
1566 const VkSubpassDescription2 subpassDesc =
1568 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, // sType
1569 (useAttachmentInfo ? &shadingRateAttachmentInfo : nullptr), // pNext;
1570 (vk::VkSubpassDescriptionFlags)0, // flags
1571 vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
1572 m_data.multiView ? 0x3 : 0u, // viewMask
1574 DE_NULL, // pInputAttachments
1576 &colorAttachmentReference, // pColorAttachments
1577 DE_NULL, // pResolveAttachments
1578 m_data.useDepthStencil ? &depthAttachmentReference : DE_NULL, // depthStencilAttachment
1579 0u, // preserveCount
1580 DE_NULL, // pPreserveAttachments
1583 std::vector<VkAttachmentDescription2> attachmentDescriptions
1586 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1587 DE_NULL, // const void* pNext;
1588 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1589 cbFormat, // VkFormat format;
1590 m_data.samples, // VkSampleCountFlagBits samples;
1591 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1592 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1593 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1594 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1595 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
1596 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
1599 if (m_data.useAttachment())
1600 attachmentDescriptions.push_back(
1602 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1603 DE_NULL, // const void* pNext;
1604 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1605 srFormat, // VkFormat format;
1606 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1607 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1608 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1609 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1610 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1611 srLayout, // VkImageLayout initialLayout;
1612 srLayout // VkImageLayout finalLayout;
1616 if (m_data.useDepthStencil)
1617 attachmentDescriptions.push_back(
1619 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1620 DE_NULL, // const void* pNext;
1621 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1622 dsFormat, // VkFormat format;
1623 m_data.samples, // VkSampleCountFlagBits samples;
1624 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1625 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1626 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp stencilLoadOp;
1627 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp;
1628 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
1629 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
1633 const deUint32 correlatedViewMask = 0x3;
1634 const VkRenderPassCreateInfo2 renderPassParams =
1636 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, // sType
1638 (vk::VkRenderPassCreateFlags)0,
1639 (deUint32)attachmentDescriptions.size(), // attachmentCount
1640 &attachmentDescriptions[0], // pAttachments
1642 &subpassDesc, // pSubpasses
1643 0u, // dependencyCount
1644 DE_NULL, // pDependencies
1645 m_data.correlationMask, // correlatedViewMaskCount
1646 m_data.correlationMask ? &correlatedViewMask : DE_NULL // pCorrelatedViewMasks
1649 renderPass = createRenderPass2(vk, device, &renderPassParams);
1651 std::vector<VkFramebufferAttachmentImageInfo> framebufferAttachmentImageInfo;
1652 framebufferAttachmentImageInfo.push_back(
1654 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1655 DE_NULL, // const void* pNext;
1656 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1657 cbUsage, // VkImageUsageFlags usage;
1658 m_data.framebufferDim.width, // deUint32 width;
1659 m_data.framebufferDim.height, // deUint32 height;
1660 m_data.numColorLayers, // deUint32 layerCount;
1661 1u, // deUint32 viewFormatCount;
1662 &cbFormat // const VkFormat* pViewFormats;
1665 if (m_data.useAttachment())
1666 framebufferAttachmentImageInfo.push_back(
1668 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1669 DE_NULL, // const void* pNext;
1670 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1671 srUsage, // VkImageUsageFlags usage;
1672 srWidth, // deUint32 width;
1673 srHeight, // deUint32 height;
1674 numSRLayers, // deUint32 layerCount;
1675 1u, // deUint32 viewFormatCount;
1676 &srFormat // const VkFormat* pViewFormats;
1680 if (m_data.useDepthStencil)
1681 framebufferAttachmentImageInfo.push_back(
1683 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1684 DE_NULL, // const void* pNext;
1685 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1686 dsUsage, // VkImageUsageFlags usage;
1687 m_data.framebufferDim.width, // deUint32 width;
1688 m_data.framebufferDim.height, // deUint32 height;
1689 m_data.numColorLayers, // deUint32 layerCount;
1690 1u, // deUint32 viewFormatCount;
1691 &dsFormat // const VkFormat* pViewFormats;
1695 const VkFramebufferAttachmentsCreateInfo framebufferAttachmentsCreateInfo =
1697 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, // VkStructureType sType;
1698 DE_NULL, // const void* pNext;
1699 (deUint32)framebufferAttachmentImageInfo.size(), // deUint32 attachmentImageInfoCount;
1700 &framebufferAttachmentImageInfo[0] // const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos;
1703 const vk::VkFramebufferCreateInfo framebufferParams =
1705 vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
1706 imagelessFB ? &framebufferAttachmentsCreateInfo : DE_NULL, // pNext
1707 (vk::VkFramebufferCreateFlags)(imagelessFB ? VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT : 0),
1708 *renderPass, // renderPass
1709 (deUint32)attachments.size(), // attachmentCount
1710 imagelessFB ? DE_NULL : &attachments[0], // pAttachments
1711 m_data.framebufferDim.width, // width
1712 m_data.framebufferDim.height, // height
1713 m_data.multiView ? 1 : m_data.numColorLayers, // layers
1716 framebuffer = createFramebuffer(vk, device, &framebufferParams);
1719 const VkVertexInputBindingDescription vertexBinding =
1721 0u, // deUint32 binding;
1722 sizeof(float) * 2, // deUint32 stride;
1723 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
1725 const VkVertexInputAttributeDescription vertexInputAttributeDescription =
1727 0u, // deUint32 location;
1728 0u, // deUint32 binding;
1729 VK_FORMAT_R32G32_SFLOAT, // VkFormat format;
1730 0u // deUint32 offset;
1733 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
1735 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1736 DE_NULL, // const void* pNext;
1737 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
1738 1u, // deUint32 vertexBindingDescriptionCount;
1739 &vertexBinding, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1740 1u, // deUint32 vertexAttributeDescriptionCount;
1741 &vertexInputAttributeDescription // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1744 const VkPipelineRasterizationConservativeStateCreateInfoEXT consRastState =
1746 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, // VkStructureType sType;
1747 DE_NULL, // const void* pNext;
1748 (VkPipelineRasterizationConservativeStateCreateFlagsEXT)0, // VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
1749 m_data.conservativeMode, // VkConservativeRasterizationModeEXT conservativeRasterizationMode;
1750 0.0f, // float extraPrimitiveOverestimationSize;
1753 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
1755 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1756 m_data.conservativeEnable ? &consRastState : DE_NULL, // const void* pNext;
1757 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
1758 VK_FALSE, // VkBool32 depthClampEnable;
1759 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
1760 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1761 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
1762 VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace;
1763 VK_FALSE, // VkBool32 depthBiasEnable;
1764 0.0f, // float depthBiasConstantFactor;
1765 0.0f, // float depthBiasClamp;
1766 0.0f, // float depthBiasSlopeFactor;
1767 1.0f // float lineWidth;
1770 // Kill some bits from each AA mode
1771 const VkSampleMask sampleMask = m_data.sampleMaskTest ? 0x9 : 0x7D56;
1772 const VkSampleMask* pSampleMask = m_data.useApiSampleMask ? &sampleMask : DE_NULL;
1774 // All samples at pixel center. We'll validate that pixels are fully covered or uncovered.
1775 std::vector<VkSampleLocationEXT> sampleLocations(m_data.samples, { 0.5f, 0.5f });
1776 const VkSampleLocationsInfoEXT sampleLocationsInfo =
1778 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, // VkStructureType sType;
1779 DE_NULL, // const void* pNext;
1780 (VkSampleCountFlagBits)m_data.samples, // VkSampleCountFlagBits sampleLocationsPerPixel;
1781 { 1, 1 }, // VkExtent2D sampleLocationGridSize;
1782 (deUint32)m_data.samples, // uint32_t sampleLocationsCount;
1783 &sampleLocations[0], // const VkSampleLocationEXT* pSampleLocations;
1786 const VkPipelineSampleLocationsStateCreateInfoEXT pipelineSampleLocationsCreateInfo =
1788 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, // VkStructureType sType;
1789 DE_NULL, // const void* pNext;
1790 VK_TRUE, // VkBool32 sampleLocationsEnable;
1791 sampleLocationsInfo, // VkSampleLocationsInfoEXT sampleLocationsInfo;
1794 const VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo =
1796 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType
1797 m_data.sampleLocations ? &pipelineSampleLocationsCreateInfo : DE_NULL, // const void* pNext
1798 0u, // VkPipelineMultisampleStateCreateFlags flags
1799 (VkSampleCountFlagBits)m_data.samples, // VkSampleCountFlagBits rasterizationSamples
1800 (VkBool32)m_data.sampleShadingEnable, // VkBool32 sampleShadingEnable
1801 1.0f, // float minSampleShading
1802 pSampleMask, // const VkSampleMask* pSampleMask
1803 VK_FALSE, // VkBool32 alphaToCoverageEnable
1804 VK_FALSE // VkBool32 alphaToOneEnable
1807 std::vector<VkViewport> viewports;
1808 std::vector<VkRect2D> scissors;
1809 if (m_data.multiViewport)
1811 // Split the viewport into left and right halves
1812 int x0 = 0, x1 = m_data.framebufferDim.width/2, x2 = m_data.framebufferDim.width;
1814 viewports.push_back(makeViewport((float)x0, 0, (float)(x1-x0), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1815 scissors.push_back(makeRect2D(x0, 0, x1-x0, m_data.framebufferDim.height));
1817 viewports.push_back(makeViewport((float)x1, 0, (float)(x2-x1), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1818 scissors.push_back(makeRect2D(x1, 0, x2-x1, m_data.framebufferDim.height));
1822 viewports.push_back(makeViewport(m_data.framebufferDim.width, m_data.framebufferDim.height));
1823 scissors.push_back(makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height));
1826 Move<VkShaderModule> fragShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0);
1827 Move<VkShaderModule> vertShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0);
1828 Move<VkShaderModule> geomShader;
1829 if (m_data.geometryShader)
1830 geomShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("geom"), 0);
1832 const deUint32 fragSizeWH = m_data.sampleMaskTest ? 2 : 0;
1834 PipelineRenderingCreateInfoWrapper renderingCreateInfoWrapper;
1835 #ifndef CTS_USES_VULKANSC
1836 VkPipelineRenderingCreateInfoKHR renderingCreateInfo
1838 VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
1840 m_data.multiView ? 0x3 : 0u,
1846 renderingCreateInfoWrapper.ptr = m_data.groupParams->useDynamicRendering ? &renderingCreateInfo : DE_NULL;
1847 #endif // CTS_USES_VULKANSC
1849 VkPipelineFragmentShadingRateStateCreateInfoKHR shadingRateStateCreateInfo
1851 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, // VkStructureType sType;
1852 renderingCreateInfoWrapper.ptr, // const void* pNext;
1853 { fragSizeWH, fragSizeWH }, // VkExtent2D fragmentSize;
1854 { m_data.combinerOp[0], m_data.combinerOp[1] }, // VkFragmentShadingRateCombinerOpKHR combinerOps[2];
1857 VkDynamicState dynamicState = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR;
1858 const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo
1860 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
1861 DE_NULL, // const void* pNext;
1862 (VkPipelineDynamicStateCreateFlags)0, // VkPipelineDynamicStateCreateFlags flags;
1863 m_data.useDynamicState ? 1u : 0u, // uint32_t dynamicStateCount;
1864 &dynamicState, // const VkDynamicState* pDynamicStates;
1867 // Enable depth/stencil writes, always passing
1868 VkPipelineDepthStencilStateCreateInfo depthStencilStateParams
1870 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
1871 DE_NULL, // const void* pNext;
1872 0u, // VkPipelineDepthStencilStateCreateFlags flags;
1873 VK_TRUE, // VkBool32 depthTestEnable;
1874 VK_TRUE, // VkBool32 depthWriteEnable;
1875 VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp;
1876 VK_FALSE, // VkBool32 depthBoundsTestEnable;
1877 VK_TRUE, // VkBool32 stencilTestEnable;
1878 // VkStencilOpState front;
1880 VK_STENCIL_OP_REPLACE, // VkStencilOp failOp;
1881 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
1882 VK_STENCIL_OP_REPLACE, // VkStencilOp depthFailOp;
1883 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1884 0u, // deUint32 compareMask;
1885 0xFFu, // deUint32 writeMask;
1886 0xFFu, // deUint32 reference;
1888 // VkStencilOpState back;
1890 VK_STENCIL_OP_REPLACE, // VkStencilOp failOp;
1891 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
1892 VK_STENCIL_OP_REPLACE, // VkStencilOp depthFailOp;
1893 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1894 0u, // deUint32 compareMask;
1895 0xFFu, // deUint32 writeMask;
1896 0xFFu, // deUint32 reference;
1898 0.0f, // float minDepthBounds;
1899 0.0f, // float maxDepthBounds;
1902 const VkQueue queue = m_context.getUniversalQueue();
1903 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, m_context.getUniversalQueueFamilyIndex());
1904 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1905 Move<VkCommandBuffer> secCmdBuffer;
1906 VkClearValue clearColor = makeClearValueColorU32(0, 0, 0, 0);
1907 VkClearValue clearDepthStencil = makeClearValueDepthStencil(0.0, 0);
1909 std::vector<GraphicsPipelineWrapper> pipelines;
1910 pipelines.reserve(m_data.useDynamicState ? 1u : NUM_TRIANGLES);
1912 #ifndef CTS_USES_VULKANSC
1913 const VkExtent2D srTexelSize { srTexelWidth, srTexelHeight };
1914 if (m_data.groupParams->useSecondaryCmdBuffer)
1916 secCmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
1918 // record secondary command buffer
1919 if (m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
1921 beginSecondaryCmdBuffer(*secCmdBuffer, cbFormat, dsFormat, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT);
1922 beginDynamicRender(*secCmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView,
1923 clearColor, clearDepthStencil);
1926 beginSecondaryCmdBuffer(*secCmdBuffer, cbFormat, dsFormat);
1928 drawCommands(*secCmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
1929 &vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
1930 &depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
1931 renderingCreateInfoWrapper, *vertShader, *geomShader, *fragShader, *descriptorSet, **vertexBuffer);
1933 if (m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
1934 endRendering(vk, *secCmdBuffer);
1936 endCommandBuffer(vk, *secCmdBuffer);
1938 // record primary command buffer
1939 beginCommandBuffer(vk, *cmdBuffer, 0u);
1941 preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
1942 srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
1943 if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
1944 beginDynamicRender(*cmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView,
1945 clearColor, clearDepthStencil, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR);
1947 vk.cmdExecuteCommands(*cmdBuffer, 1u, &*secCmdBuffer);
1949 if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
1950 endRendering(vk, *cmdBuffer);
1952 else if (m_data.groupParams->useDynamicRendering)
1954 beginCommandBuffer(vk, *cmdBuffer);
1955 preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
1956 srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
1957 beginDynamicRender(*cmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView, clearColor, clearDepthStencil);
1958 drawCommands(*cmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
1959 &vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
1960 &depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
1961 renderingCreateInfoWrapper, *vertShader, *geomShader, *fragShader, *descriptorSet, **vertexBuffer);
1962 endRendering(vk, *cmdBuffer);
1964 #endif // CTS_USES_VULKANSC
1966 if (!m_data.groupParams->useDynamicRendering)
1968 beginCommandBuffer(vk, *cmdBuffer);
1969 preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
1970 srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
1971 beginLegacyRender(*cmdBuffer, *renderPass, *framebuffer, *srImageView, *cbImageView, *dsImageView, imagelessFB);
1972 drawCommands(*cmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
1973 &vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
1974 &depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
1975 renderingCreateInfoWrapper, *vertShader, *geomShader, *fragShader, *descriptorSet, **vertexBuffer);
1976 endRenderPass(vk, *cmdBuffer);
1979 VkMemoryBarrier memBarrier
1981 VK_STRUCTURE_TYPE_MEMORY_BARRIER,
1983 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
1984 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT
1986 vk.cmdPipelineBarrier(*cmdBuffer, allPipelineStages, allPipelineStages, 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
1988 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1, &*descriptorSet, 0u, DE_NULL);
1989 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline);
1991 // Copy color/depth/stencil buffers to buffer memory
1992 vk.cmdDispatch(*cmdBuffer, m_data.framebufferDim.width, m_data.framebufferDim.height, m_data.numColorLayers);
1994 memBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
1995 memBarrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
1996 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
1997 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
1999 endCommandBuffer(vk, *cmdBuffer);
2001 submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
2003 deUint32 *colorptr = (deUint32 *)colorOutputBuffer->getAllocation().getHostPtr();
2004 invalidateAlloc(vk, device, colorOutputBuffer->getAllocation());
2006 invalidateAlloc(vk, device, atomicBuffer->getAllocation());
2008 float *depthptr = DE_NULL;
2009 deUint32 *stencilptr = DE_NULL;
2011 if (m_data.useDepthStencil)
2013 depthptr = (float *)depthOutputBuffer->getAllocation().getHostPtr();
2014 invalidateAlloc(vk, device, depthOutputBuffer->getAllocation());
2016 stencilptr = (deUint32 *)stencilOutputBuffer->getAllocation().getHostPtr();
2017 invalidateAlloc(vk, device, stencilOutputBuffer->getAllocation());
2020 // Loop over all samples and validate the output
2021 for (deUint32 layer = 0; layer < m_data.numColorLayers && res == QP_TEST_RESULT_PASS; ++layer)
2023 for (deUint32 y = 0; y < m_data.framebufferDim.height && res == QP_TEST_RESULT_PASS; ++y)
2025 for (deUint32 x = 0; x < m_data.framebufferDim.width && res == QP_TEST_RESULT_PASS; ++x)
2027 for (deInt32 s = 0; s < m_data.samples && res == QP_TEST_RESULT_PASS; ++s)
2029 deUint32 *sample = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2031 // If testing the rasterizer sample mask, if this sample is not set in the
2032 // mask then it shouldn't have written anything.
2033 if (m_data.useApiSampleMask && !(sampleMask & (1 << s)) && sample[2] != 0)
2035 log << tcu::TestLog::Message << std::hex << "sample written despite pSampleMask (" << x << "," << y << ",sample " << s << ")" << tcu::TestLog::EndMessage;
2036 res = QP_TEST_RESULT_FAIL;
2040 // The same isn't covered by any primitives, skip it
2044 // skip samples that have the same value as sample zero - it would be redundant to check them.
2047 deUint32 *sample0 = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0)];
2048 bool same = deMemCmp(sample, sample0, 16) == 0;
2050 if (m_data.fragDepth)
2052 float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2053 float *dsample0 = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2054 same = same && (*dsample == *dsample0);
2057 if (m_data.fragStencil)
2059 deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2060 deUint32 *ssample0 = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2061 same = same && (*ssample == *ssample0);
2068 // Fragment shader writes error codes to .w component.
2069 // All nonzero values are unconditionally failures
2072 if (sample[3] == ERROR_FRAGCOORD_CENTER)
2073 log << tcu::TestLog::Message << std::hex << "fragcoord test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2074 else if (sample[3] == ERROR_VTG_READBACK)
2075 log << tcu::TestLog::Message << std::hex << "vs/gs output readback test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2076 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_DERIV)
2077 log << tcu::TestLog::Message << std::hex << "fragcoord derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2078 "(0x" << ((sample[3] >> 8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2079 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2080 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_IMPLICIT_DERIV)
2081 log << tcu::TestLog::Message << std::hex << "implicit derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2082 "(0x" << ((sample[3] >> 8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2083 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2085 log << tcu::TestLog::Message << std::hex << "w coord unknown test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2086 res = QP_TEST_RESULT_FAIL;
2090 // x component of sample
2091 deUint32 rate = sample[0];
2093 deUint32 pixelsX = 1 << ((rate/4)&3);
2094 deUint32 pixelsY = 1 << (rate&3);
2097 deUint32 fragMinX = x & ~(pixelsX-1);
2098 deUint32 fragMinY = y & ~(pixelsY-1);
2099 deUint32 fragMaxX = fragMinX + pixelsX;
2100 deUint32 fragMaxY = fragMinY + pixelsY;
2102 // Clamp to FB dimension for odd sizes
2103 if (fragMaxX > m_data.framebufferDim.width)
2104 fragMaxX = m_data.framebufferDim.width;
2105 if (fragMaxY > m_data.framebufferDim.height)
2106 fragMaxY = m_data.framebufferDim.height;
2108 // z component of sample
2109 deUint32 primID = sample[2] >> 24;
2110 deUint32 atomVal = sample[2] & 0xFFFFFF;
2112 // Compute pipeline and primitive rate from primitive ID, and attachment
2113 // rate from the x/y coordinate
2114 deInt32 pipelineRate = PrimIDToPipelineShadingRate(primID);
2115 deInt32 primitiveRate = m_data.shaderWritesRate ? PrimIDToPrimitiveShadingRate(primID) : 0;
2117 deInt32 attachmentLayer = (m_data.srLayered && modeIdx == ATTACHMENT_MODE_2DARRAY) ? layer : 0;
2118 deInt32 attachmentRate = m_data.useAttachment() ? fillPtr[srFillBpp*((attachmentLayer * srHeight + (y / srTexelHeight)) * srWidth + (x / srTexelWidth))] : 0;
2120 // Get mask of allowed shading rates
2121 deInt32 expectedMasks = Simulate(pipelineRate, primitiveRate, attachmentRate);
2123 if (!(expectedMasks & (1 << rate)))
2125 log << tcu::TestLog::Message << std::hex << "unexpected shading rate. failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ") "
2126 "result rate 0x" << rate << " mask of expected rates 0x" << expectedMasks <<
2127 " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate << tcu::TestLog::EndMessage;
2128 res = QP_TEST_RESULT_FAIL;
2131 // Check that not all fragments are downgraded to 1x1
2132 if (rate == 0 && expectedMasks != 1)
2133 numUnexpected1x1Samples++;
2136 // Check that gl_FragDepth = primID / NUM_TRIANGLES
2137 if (m_data.fragDepth)
2139 float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2140 float expected = (float)primID / NUM_TRIANGLES;
2141 if (fabs(*dsample - expected) > 0.01)
2143 log << tcu::TestLog::Message << std::hex << "depth write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *dsample << " expected " << expected << tcu::TestLog::EndMessage;
2144 res = QP_TEST_RESULT_FAIL;
2149 // Check that stencil value = primID
2150 if (m_data.fragStencil)
2152 deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2153 if (*ssample != primID)
2155 log << tcu::TestLog::Message << std::hex << "stencil write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *ssample << " expected " << primID << tcu::TestLog::EndMessage;
2156 res = QP_TEST_RESULT_FAIL;
2161 // Check that primitives are in the right viewport/scissor
2162 if (m_data.multiViewport)
2164 VkRect2D *scissor = &scissors[primID & 1];
2165 if ((int)x < scissor->offset.x || (int)x >= (int)(scissor->offset.x + scissor->extent.width) ||
2166 (int)y < scissor->offset.y || (int)y >= (int)(scissor->offset.y + scissor->extent.height))
2168 log << tcu::TestLog::Message << std::hex << "primitive found outside of expected viewport (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << tcu::TestLog::EndMessage;
2169 res = QP_TEST_RESULT_FAIL;
2174 // Check that primitives are in the right layer
2175 if (m_data.colorLayered)
2177 if (layer != ((primID & 2)>>1))
2179 log << tcu::TestLog::Message << std::hex << "primitive found in wrong layer (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << " layer=" << layer << tcu::TestLog::EndMessage;
2180 res = QP_TEST_RESULT_FAIL;
2185 // Check that multiview broadcasts the same primitive to both layers
2186 if (m_data.multiView)
2188 deUint32 otherLayer = layer^1;
2189 deUint32 *othersample = &colorptr[4*(((otherLayer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2190 deUint32 otherPrimID = othersample[2] >> 24;
2191 if (primID != otherPrimID)
2193 log << tcu::TestLog::Message << std::hex << "multiview primitive mismatch (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << " otherPrimID=" << otherPrimID << tcu::TestLog::EndMessage;
2194 res = QP_TEST_RESULT_FAIL;
2199 // Loop over all samples in the same fragment
2200 for (deUint32 fx = fragMinX; fx < fragMaxX; ++fx)
2202 for (deUint32 fy = fragMinY; fy < fragMaxY; ++fy)
2204 for (deInt32 fs = 0; fs < m_data.samples; ++fs)
2206 deUint32 *fsample = &colorptr[4*(((layer * m_data.framebufferDim.height + fy) * m_data.framebufferDim.width + fx)*m_data.samples + fs)];
2207 deUint32 frate = fsample[0];
2208 deUint32 fprimID = fsample[2] >> 24;
2209 deUint32 fatomVal = fsample[2] & 0xFFFFFF;
2211 // If we write out the sample mask value, check that the samples in the
2212 // mask must not be uncovered, and that samples not in the mask must not
2213 // be covered by this primitive
2214 if (m_data.useSampleMaskIn)
2216 int p = pixelsX * pixelsY - ((fx - fragMinX) + pixelsX * (fy - fragMinY)) - 1;
2217 int sampleIdx = fs + m_data.samples * p;
2219 if ((sample[1] & (1 << sampleIdx)) && fsample[2] == 0)
2221 log << tcu::TestLog::Message << std::hex << "sample set in sampleMask but not written (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2222 res = QP_TEST_RESULT_FAIL;
2225 if (!(sample[1] & (1 << sampleIdx)) && fsample[2] != 0 && fprimID == primID)
2227 log << tcu::TestLog::Message << std::hex << "sample not set in sampleMask but written with same primID (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2228 res = QP_TEST_RESULT_FAIL;
2233 // If conservative raster is enabled, or custom sample locations all at the center, check that
2234 // samples in the same pixel must be covered.
2235 if (m_data.conservativeEnable ||
2236 (m_data.sampleLocations && m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations))
2238 // If it's in the same pixel, expect it to be fully covered.
2239 if (fx == x && fy == y && fsample[2] == 0)
2241 log << tcu::TestLog::Message << std::hex << "pixel not fully covered (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2242 res = QP_TEST_RESULT_FAIL;
2247 if (fsample[2] == 0)
2250 // If the primitive matches this sample, then it must have the same rate and
2252 if (fprimID == primID)
2254 if (rate != frate || (atomVal != fatomVal && !(m_data.sampleShadingEnable || m_data.sampleShadingInput)))
2256 log << tcu::TestLog::Message << std::hex << "failed pixel (0x" << x << ",0x" << y << ",sample " << s << ")=0x" << ((primID<<24)|atomVal) <<
2257 " compared to (0x" << fx << ",0x" << fy << ",sample " << fs << ")=0x" << ((fprimID<<24)|fatomVal) <<
2258 " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate <<
2259 tcu::TestLog::EndMessage;
2260 res = QP_TEST_RESULT_FAIL;
2270 if (res == QP_TEST_RESULT_FAIL)
2274 // All samples were coerced to 1x1, unexpected
2275 if (res == QP_TEST_RESULT_PASS &&
2276 numTotalSamples != 0 &&
2277 numUnexpected1x1Samples == numTotalSamples &&
2278 numTotalSamples > 16)
2280 log << tcu::TestLog::Message << std::hex << "Quality warning - all fragments used 1x1" << tcu::TestLog::EndMessage;
2281 res = QP_TEST_RESULT_QUALITY_WARNING;
2284 return tcu::TestStatus(res, qpGetTestResultName(res));
2287 #ifndef CTS_USES_VULKANSC
2288 void FSRTestInstance::beginSecondaryCmdBuffer(VkCommandBuffer cmdBuffer, VkFormat cbFormat, VkFormat dsFormat, VkRenderingFlagsKHR renderingFlags) const
2290 VkCommandBufferInheritanceRenderingInfoKHR inheritanceRenderingInfo
2292 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR, // VkStructureType sType;
2293 DE_NULL, // const void* pNext;
2294 renderingFlags, // VkRenderingFlagsKHR flags;
2295 m_data.multiView ? 0x3 : 0u, // uint32_t viewMask;
2296 1u, // uint32_t colorAttachmentCount;
2297 &cbFormat, // const VkFormat* pColorAttachmentFormats;
2298 dsFormat, // VkFormat depthAttachmentFormat;
2299 dsFormat, // VkFormat stencilAttachmentFormat;
2300 m_data.samples, // VkSampleCountFlagBits rasterizationSamples;
2302 const VkCommandBufferInheritanceInfo bufferInheritanceInfo = initVulkanStructure(&inheritanceRenderingInfo);
2304 VkCommandBufferUsageFlags usageFlags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
2305 if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
2306 usageFlags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
2308 const VkCommandBufferBeginInfo commandBufBeginParams
2310 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2311 DE_NULL, // const void* pNext;
2312 usageFlags, // VkCommandBufferUsageFlags flags;
2313 &bufferInheritanceInfo
2316 const DeviceInterface& vk = m_context.getDeviceInterface();
2317 VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &commandBufBeginParams));
2320 void FSRTestInstance::beginDynamicRender(VkCommandBuffer cmdBuffer, VkImageView srImageView, VkImageLayout srImageLayout,
2321 const VkExtent2D& srTexelSize, VkImageView cbImageView, VkImageView dsImageView,
2322 const VkClearValue& clearColor, const VkClearValue& clearDepthStencil,
2323 VkRenderingFlagsKHR renderingFlags) const
2325 const DeviceInterface& vk = m_context.getDeviceInterface();
2326 VkRect2D renderArea = makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height);
2328 VkRenderingFragmentShadingRateAttachmentInfoKHR shadingRateAttachmentInfo
2330 VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, // VkStructureType sType;
2331 DE_NULL, // const void* pNext;
2332 m_data.useAttachment() ? srImageView : DE_NULL, // VkImageView imageView;
2333 srImageLayout, // VkImageLayout imageLayout;
2334 srTexelSize // VkExtent2D shadingRateAttachmentTexelSize;
2337 VkRenderingAttachmentInfoKHR colorAttachment
2339 vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
2340 DE_NULL, // const void* pNext;
2341 cbImageView, // VkImageView imageView;
2342 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout imageLayout;
2343 VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
2344 DE_NULL, // VkImageView resolveImageView;
2345 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
2346 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
2347 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2348 clearColor // VkClearValue clearValue;
2351 std::vector<VkRenderingAttachmentInfoKHR> depthStencilAttachments(2,
2353 VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
2354 DE_NULL, // const void* pNext;
2355 dsImageView, // VkImageView imageView;
2356 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout imageLayout;
2357 VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
2358 DE_NULL, // VkImageView resolveImageView;
2359 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
2360 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
2361 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2362 clearDepthStencil // VkClearValue clearValue;
2365 vk::VkRenderingInfoKHR renderingInfo
2367 vk::VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
2368 m_data.useAttachment() || m_data.useAttachmentWithoutImageView() ? &shadingRateAttachmentInfo : DE_NULL,
2369 renderingFlags, // VkRenderingFlagsKHR flags;
2370 renderArea, // VkRect2D renderArea;
2371 m_data.multiView ? 1 : m_data.numColorLayers, // deUint32 layerCount;
2372 m_data.multiView ? 0x3 : 0u, // deUint32 viewMask;
2373 1u, // deUint32 colorAttachmentCount;
2374 &colorAttachment, // const VkRenderingAttachmentInfoKHR* pColorAttachments;
2375 m_data.useDepthStencil ? &depthStencilAttachments[0] : DE_NULL, // const VkRenderingAttachmentInfoKHR* pDepthAttachment;
2376 m_data.useDepthStencil ? &depthStencilAttachments[1] : DE_NULL, // const VkRenderingAttachmentInfoKHR* pStencilAttachment;
2379 vk.cmdBeginRendering(cmdBuffer, &renderingInfo);
2381 #endif // CTS_USES_VULKANSC
2383 void FSRTestInstance::preRenderCommands(VkCommandBuffer cmdBuffer, ImageWithMemory* cbImage, ImageWithMemory* dsImage,
2384 ImageWithMemory* derivImage, deUint32 derivNumLevels,
2385 ImageWithMemory* srImage, VkImageLayout srLayout, BufferWithMemory* srFillBuffer,
2386 deUint32 numSRLayers, deUint32 srWidth, deUint32 srHeight, deUint32 srFillBpp,
2387 const VkClearValue& clearColor, const VkClearValue& clearDepthStencil)
2389 const DeviceInterface& vk = m_context.getDeviceInterface();
2390 const VkDevice device = m_context.getDevice();
2392 VkFlags allPipelineStages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
2393 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
2394 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
2395 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
2396 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
2397 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
2398 VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
2400 if (m_data.geometryShader)
2401 allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
2403 VkImageMemoryBarrier imageBarrier
2405 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
2406 DE_NULL, // const void* pNext
2407 0u, // VkAccessFlags srcAccessMask
2408 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
2409 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout
2410 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout newLayout
2411 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
2412 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
2413 cbImage->get(), // VkImage image
2415 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
2416 0u, // uint32_t baseMipLevel
2417 VK_REMAINING_MIP_LEVELS, // uint32_t mipLevels,
2418 0u, // uint32_t baseArray
2419 VK_REMAINING_ARRAY_LAYERS, // uint32_t arraySize
2423 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2424 (VkDependencyFlags)0,
2425 0, (const VkMemoryBarrier*)DE_NULL,
2426 0, (const VkBufferMemoryBarrier*)DE_NULL,
2429 imageBarrier.image = derivImage->get();
2430 imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
2432 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2433 (VkDependencyFlags)0,
2434 0, (const VkMemoryBarrier*)DE_NULL,
2435 0, (const VkBufferMemoryBarrier*)DE_NULL,
2438 // Clear level to 1<<level
2439 for (deUint32 i = 0; i < derivNumLevels; ++i)
2441 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, i, 1u, 0u, 1u);
2442 VkClearValue clearLevelColor = makeClearValueColorU32(1<<i,0,0,0);
2443 vk.cmdClearColorImage(cmdBuffer, derivImage->get(), VK_IMAGE_LAYOUT_GENERAL, &clearLevelColor.color, 1, &range);
2446 // Clear color buffer to transparent black
2448 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
2449 vk.cmdClearColorImage(cmdBuffer, cbImage->get(), VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);
2452 // Clear depth and stencil
2453 if (m_data.useDepthStencil)
2455 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
2456 VkImageMemoryBarrier dsBarrier = imageBarrier;
2457 dsBarrier.image = dsImage->get();
2458 dsBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
2459 dsBarrier.subresourceRange = range;
2460 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2461 0u, // dependencyFlags
2465 vk.cmdClearDepthStencilImage(cmdBuffer, dsImage->get(), VK_IMAGE_LAYOUT_GENERAL, &clearDepthStencil.depthStencil, 1, &range);
2468 // Initialize shading rate image with varying values
2469 if (m_data.useAttachment())
2471 imageBarrier.image = srImage->get();
2472 imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
2474 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2475 (VkDependencyFlags)0,
2476 0, (const VkMemoryBarrier*)DE_NULL,
2477 0, (const VkBufferMemoryBarrier*)DE_NULL,
2480 deUint8 *fillPtr = (deUint8 *)srFillBuffer->getAllocation().getHostPtr();
2481 for (deUint32 layer = 0; layer < numSRLayers; ++layer)
2483 for (deUint32 x = 0; x < srWidth; ++x)
2485 for (deUint32 y = 0; y < srHeight; ++y)
2487 deUint32 idx = (layer*srHeight + y)*srWidth + x;
2488 deUint8 val = (deUint8)SanitizeRate(idx & 0xF);
2489 // actual shading rate is always in the LSBs of the first byte of a texel
2490 fillPtr[srFillBpp*idx] = val;
2494 flushAlloc(vk, device, srFillBuffer->getAllocation());
2496 const VkBufferImageCopy copyRegion
2498 0u, // VkDeviceSize bufferOffset;
2499 0u, // deUint32 bufferRowLength;
2500 0u, // deUint32 bufferImageHeight;
2502 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspect;
2503 0u, // deUint32 mipLevel;
2504 0u, // deUint32 baseArrayLayer;
2505 numSRLayers, // deUint32 layerCount;
2506 }, // VkImageSubresourceLayers imageSubresource;
2507 { 0, 0, 0 }, // VkOffset3D imageOffset;
2508 { srWidth, srHeight, 1 }, // VkExtent3D imageExtent;
2511 vk.cmdCopyBufferToImage(cmdBuffer, srFillBuffer->get(), srImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
2513 imageBarrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
2514 imageBarrier.newLayout = srLayout;
2516 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2517 (VkDependencyFlags)0,
2518 0, (const VkMemoryBarrier*)DE_NULL,
2519 0, (const VkBufferMemoryBarrier*)DE_NULL,
2523 VkMemoryBarrier memBarrier
2525 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
2527 0u, // srcAccessMask
2528 0u, // dstAccessMask
2531 memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
2532 memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
2533 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, allPipelineStages,
2534 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2537 void FSRTestInstance::beginLegacyRender(VkCommandBuffer cmdBuffer, VkRenderPass renderPass, VkFramebuffer framebuffer,
2538 VkImageView srImageView, VkImageView cbImageView, VkImageView dsImageView, bool imagelessFB) const
2540 const DeviceInterface& vk = m_context.getDeviceInterface();
2541 VkRect2D renderArea = makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height);
2543 std::vector<VkImageView> attachments = { cbImageView };
2544 if (m_data.useAttachment())
2545 attachments.push_back(srImageView);
2546 if (m_data.useDepthStencil)
2547 attachments.push_back(dsImageView);
2549 const VkRenderPassAttachmentBeginInfo renderPassAttachmentBeginInfo
2551 VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, // VkStructureType sType;
2552 DE_NULL, // const void* pNext;
2553 (deUint32)attachments.size(), // deUint32 attachmentCount;
2554 &attachments[0] // const VkImageView* pAttachments;
2557 beginRenderPass(vk, cmdBuffer, renderPass, framebuffer, renderArea,
2558 0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE, imagelessFB ? &renderPassAttachmentBeginInfo : DE_NULL);
2561 void FSRTestInstance::drawCommands(VkCommandBuffer cmdBuffer,
2562 std::vector<GraphicsPipelineWrapper>& pipelines,
2563 const std::vector<VkViewport>& viewports,
2564 const std::vector<VkRect2D>& scissors,
2565 const VkPipelineLayout pipelineLayout,
2566 const VkRenderPass renderPass,
2567 const VkPipelineVertexInputStateCreateInfo* vertexInputState,
2568 const VkPipelineDynamicStateCreateInfo* dynamicState,
2569 const VkPipelineRasterizationStateCreateInfo* rasterizationState,
2570 const VkPipelineDepthStencilStateCreateInfo* depthStencilState,
2571 const VkPipelineMultisampleStateCreateInfo* multisampleState,
2572 VkPipelineFragmentShadingRateStateCreateInfoKHR* shadingRateState,
2573 PipelineRenderingCreateInfoWrapper dynamicRenderingState,
2574 const VkShaderModule vertShader,
2575 const VkShaderModule geomShader,
2576 const VkShaderModule fragShader,
2577 VkDescriptorSet descriptorSet,
2578 VkBuffer vertexBuffer)
2580 const DeviceInterface& vk = m_context.getDeviceInterface();
2581 const VkDevice device = m_context.getDevice();
2583 VkFlags allShaderStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
2584 if (m_data.geometryShader)
2585 allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
2587 VkPipelineCreateFlags pipelineCreateFlags = (VkPipelineCreateFlags)0;
2589 #ifndef CTS_USES_VULKANSC
2590 if (m_data.groupParams->useDynamicRendering)
2591 pipelineCreateFlags |= VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
2592 #endif // CTS_USES_VULKANSC
2594 vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, DE_NULL);
2596 // If using dynamic state, create a single graphics pipeline and bind it
2597 if (m_data.useDynamicState)
2599 pipelines.emplace_back(vk, device, m_data.groupParams->pipelineConstructionType, pipelineCreateFlags);
2601 .setDefaultColorBlendState()
2602 .setDynamicState(dynamicState)
2603 .setupVertexInputStete(vertexInputState)
2604 .setupPreRasterizationShaderState(viewports,
2616 dynamicRenderingState)
2617 .setupFragmentShaderState(pipelineLayout,
2623 .setupFragmentOutputState(renderPass, 0u, DE_NULL, multisampleState)
2624 .setMonolithicPipelineLayout(pipelineLayout)
2627 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.back().getPipeline());
2630 for (deInt32 i = 0; i < NUM_TRIANGLES; ++i)
2632 // Bind vertex attributes pointing to the next triangle
2633 VkDeviceSize vertexBufferOffset = i * 3 * 2 * sizeof(float);
2634 vk.cmdBindVertexBuffers(cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
2636 // Put primitive shading rate in a push constant
2637 deInt32 shadingRatePC = PrimIDToPrimitiveShadingRate(i);
2638 vk.cmdPushConstants(cmdBuffer, pipelineLayout, allShaderStages, 0, sizeof(shadingRatePC), &shadingRatePC);
2640 if (m_data.useDynamicState)
2642 VkExtent2D fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2643 vk.cmdSetFragmentShadingRateKHR(cmdBuffer, &fragmentSize, m_data.combinerOp);
2647 // Create a new pipeline with the desired pipeline shading rate
2648 shadingRateState->fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2650 pipelines.emplace_back(vk, device, m_data.groupParams->pipelineConstructionType, pipelineCreateFlags);
2652 .setDefaultColorBlendState()
2653 .setDynamicState(dynamicState)
2654 .setupVertexInputStete(vertexInputState)
2655 .setupPreRasterizationShaderState(viewports,
2667 dynamicRenderingState)
2668 .setupFragmentShaderState(pipelineLayout,
2674 .setupFragmentOutputState(renderPass, 0u, DE_NULL, multisampleState)
2675 .setMonolithicPipelineLayout(pipelineLayout)
2678 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.back().getPipeline());
2681 // Draw one triangle, with "primitive ID" in gl_InstanceIndex
2682 vk.cmdDraw(cmdBuffer, 3u, 1, 0u, i);
2688 void createBasicTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* parentGroup, SharedGroupParams groupParams)
2694 const char* description;
2701 const char* description;
2706 AttachmentUsage usage;
2708 const char* description;
2709 } TestGroupUsageCase;
2711 TestGroupCase groupCases[] =
2713 { 0, "basic", "basic tests" },
2714 { 1, "apisamplemask", "use pSampleMask" },
2715 { 2, "samplemaskin", "use gl_SampleMaskIn" },
2716 { 3, "conservativeunder", "conservative underestimation" },
2717 { 4, "conservativeover", "conservative overestimation" },
2718 { 5, "fragdepth", "depth shader output" },
2719 { 6, "fragstencil", "stencil shader output" },
2720 { 7, "multiviewport", "multiple viewports and gl_ViewportIndex" },
2721 { 8, "colorlayered", "multiple layer color, single layer shading rate" },
2722 { 9, "srlayered", "multiple layer color, multiple layers shading rate" },
2723 { 10, "multiview", "multiview" },
2724 { 11, "multiviewsrlayered", "multiview and multilayer shading rate" },
2725 { 12, "multiviewcorrelation", "multiview with correlation mask" },
2726 { 13, "interlock", "fragment shader interlock" },
2727 { 14, "samplelocations", "custom sample locations" },
2728 { 15, "sampleshadingenable", "enable sample shading in createinfo" },
2729 { 16, "sampleshadinginput", "enable sample shading by using gl_SampleID" },
2730 #ifndef CTS_USES_VULKANSC
2731 { 17, "fragdepth_early_late", "depth shader output" },
2732 { 18, "fragstencil_early_late", "stencil shader output" },
2736 TestGroupCase dynCases[] =
2738 { 1, "dynamic", "uses dynamic shading rate state" },
2739 { 0, "static", "uses static shading rate state" },
2742 TestGroupUsageCase attCases[] =
2744 { AttachmentUsage::NO_ATTACHMENT, "noattachment", "no shading rate attachment" },
2745 { AttachmentUsage::WITH_ATTACHMENT, "attachment", "has shading rate attachment" },
2746 { AttachmentUsage::NO_ATTACHMENT_PTR, "noattachmentptr", "no shading rate attachment pointer" },
2747 { AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW, "attachment_noimageview", "has shading rate attachment without imageview" },
2750 TestGroupCase shdCases[] =
2752 { 0, "noshaderrate", "shader doesn't write rate" },
2753 { 1, "shaderrate", "shader writes rate" },
2756 TestGroupCase combCases[] =
2758 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, "keep", "keep" },
2759 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR, "replace", "replace" },
2760 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, "min", "min" },
2761 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, "max", "max" },
2762 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR, "mul", "mul" },
2765 TestGroupCase2D extentCases[] =
2767 { {1, 1}, "1x1", "1x1" },
2768 { {4, 4}, "4x4", "4x4" },
2769 { {33, 35}, "33x35", "33x35" },
2770 { {151, 431}, "151x431", "151x431" },
2771 { {256, 256}, "256x256", "256x256" },
2774 TestGroupCase sampCases[] =
2776 { VK_SAMPLE_COUNT_1_BIT, "samples1", "1 raster sample" },
2777 { VK_SAMPLE_COUNT_2_BIT, "samples2", "2 raster samples" },
2778 { VK_SAMPLE_COUNT_4_BIT, "samples4", "4 raster samples" },
2779 { VK_SAMPLE_COUNT_8_BIT, "samples8", "8 raster samples" },
2780 { VK_SAMPLE_COUNT_16_BIT, "samples16", "16 raster samples" },
2783 TestGroupCase geomCases[] =
2785 { 0, "vs", "vertex shader only" },
2786 { 1, "gs", "vertex and geometry shader" },
2791 for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(groupCases); groupNdx++)
2793 if (groupParams->useDynamicRendering && groupNdx == 12)
2796 if (groupParams->pipelineConstructionType != PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC)
2798 // for graphics pipeline library we need to repeat only selected groups
2799 if (std::set<int> { 2, 3, 4, 10, 11, 12, 13, 14, 15 }.count(groupNdx) == 0)
2803 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, groupCases[groupNdx].name, groupCases[groupNdx].description));
2804 for (int dynNdx = 0; dynNdx < DE_LENGTH_OF_ARRAY(dynCases); dynNdx++)
2806 // reduce number of tests for dynamic rendering cases where secondary command buffer is used
2807 if (groupParams->useSecondaryCmdBuffer && (dynNdx != 0))
2810 de::MovePtr<tcu::TestCaseGroup> dynGroup(new tcu::TestCaseGroup(testCtx, dynCases[dynNdx].name, dynCases[dynNdx].description));
2811 for (int attNdx = 0; attNdx < DE_LENGTH_OF_ARRAY(attCases); attNdx++)
2813 if (groupParams->useDynamicRendering && attCases[attNdx].usage == AttachmentUsage::NO_ATTACHMENT_PTR)
2816 // WITH_ATTACHMENT_WITHOUT_IMAGEVIEW is only for VkRenderingFragmentShadingRateAttachmentInfoKHR.
2817 if (!groupParams->useDynamicRendering && attCases[attNdx].usage == AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW)
2820 de::MovePtr<tcu::TestCaseGroup> attGroup(new tcu::TestCaseGroup(testCtx, attCases[attNdx].name, attCases[attNdx].description));
2821 for (int shdNdx = 0; shdNdx < DE_LENGTH_OF_ARRAY(shdCases); shdNdx++)
2823 de::MovePtr<tcu::TestCaseGroup> shdGroup(new tcu::TestCaseGroup(testCtx, shdCases[shdNdx].name, shdCases[shdNdx].description));
2824 for (int cmb0Ndx = 0; cmb0Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb0Ndx++)
2826 de::MovePtr<tcu::TestCaseGroup> cmb0Group(new tcu::TestCaseGroup(testCtx, combCases[cmb0Ndx].name, combCases[cmb0Ndx].description));
2827 for (int cmb1Ndx = 0; cmb1Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb1Ndx++)
2829 de::MovePtr<tcu::TestCaseGroup> cmb1Group(new tcu::TestCaseGroup(testCtx, combCases[cmb1Ndx].name, combCases[cmb1Ndx].description));
2830 for (int extNdx = 0; extNdx < DE_LENGTH_OF_ARRAY(extentCases); extNdx++)
2832 // reduce number of cases repeat every other extent case for graphics pipeline library
2833 if ((groupParams->pipelineConstructionType != PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC) && ((extNdx % 2) == 1))
2836 // reduce number of tests for dynamic rendering cases where secondary command buffer is used
2837 if (groupParams->useSecondaryCmdBuffer && (extNdx != 1))
2840 de::MovePtr<tcu::TestCaseGroup> extGroup(new tcu::TestCaseGroup(testCtx, extentCases[extNdx].name, extentCases[extNdx].description));
2841 for (int sampNdx = 0; sampNdx < DE_LENGTH_OF_ARRAY(sampCases); sampNdx++)
2843 // reduce number of tests for dynamic rendering cases where secondary command buffer is used
2844 if (groupParams->useSecondaryCmdBuffer && (sampNdx != 1))
2847 de::MovePtr<tcu::TestCaseGroup> sampGroup(new tcu::TestCaseGroup(testCtx, sampCases[sampNdx].name, sampCases[sampNdx].description));
2848 for (int geomNdx = 0; geomNdx < DE_LENGTH_OF_ARRAY(geomCases); geomNdx++)
2850 // reduce number of tests for dynamic rendering cases where secondary command buffer is used
2851 if (groupParams->useSecondaryCmdBuffer && (geomNdx != 0))
2854 bool useApiSampleMask = groupNdx == 1;
2855 bool useSampleMaskIn = groupNdx == 2;
2856 bool consRast = groupNdx == 3 || groupNdx == 4;
2857 bool fragDepth = groupNdx == 5 || groupNdx == 17;
2858 bool fragStencil = groupNdx == 6 || groupNdx == 18;
2859 bool multiViewport = groupNdx == 7;
2860 bool colorLayered = groupNdx == 8 || groupNdx == 9;
2861 bool srLayered = groupNdx == 9 || groupNdx == 11;
2862 bool multiView = groupNdx == 10 || groupNdx == 11 || groupNdx == 12;
2863 bool correlationMask = groupNdx == 12;
2864 bool interlock = groupNdx == 13;
2865 bool sampleLocations = groupNdx == 14;
2866 bool sampleShadingEnable = groupNdx == 15;
2867 bool sampleShadingInput = groupNdx == 16;
2868 bool earlyAndLateTest = groupNdx == 17 || groupNdx == 18;
2869 VkConservativeRasterizationModeEXT conservativeMode = (groupNdx == 3) ? VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT : VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT;
2870 deUint32 numColorLayers = (colorLayered || multiView) ? 2u : 1u;
2872 // Don't bother with geometry shader if we're not testing shader writes
2873 if (geomCases[geomNdx].count && !shdCases[shdNdx].count)
2876 // reduce number of tests
2877 if ((groupNdx != 0) &&
2878 (!dynCases[dynNdx].count ||
2879 !(combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
2880 !(combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
2883 // Don't bother with geometry shader if we're testing conservative raster, sample mask, depth/stencil
2884 if (geomCases[geomNdx].count && (useApiSampleMask || useSampleMaskIn || consRast || fragDepth || fragStencil))
2887 // Don't bother with geometry shader if we're testing non-dynamic state
2888 if (geomCases[geomNdx].count && !dynCases[dynNdx].count)
2891 // Only test multiViewport/layered with shaderWritesRate
2892 if ((multiViewport || colorLayered) && !shdCases[shdNdx].count)
2895 // Can't test layered shading rate attachment without an attachment
2896 if (srLayered && attCases[attNdx].usage != AttachmentUsage::WITH_ATTACHMENT)
2901 groupParams, // SharedGroupParams groupParams;
2902 seed++, // deInt32 seed;
2903 extentCases[extNdx].count, // VkExtent2D framebufferDim;
2904 (VkSampleCountFlagBits)sampCases[sampNdx].count, // VkSampleCountFlagBits samples;
2906 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb0Ndx].count,
2907 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb1Ndx].count
2908 }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
2909 attCases[attNdx].usage, // AttachmentUsage attachmentUsage;
2910 (bool)shdCases[shdNdx].count, // bool shaderWritesRate;
2911 (bool)geomCases[geomNdx].count, // bool geometryShader;
2912 (bool)dynCases[dynNdx].count, // bool useDynamicState;
2913 useApiSampleMask, // bool useApiSampleMask;
2914 useSampleMaskIn, // bool useSampleMaskIn;
2915 consRast, // bool conservativeEnable;
2916 conservativeMode, // VkConservativeRasterizationModeEXT conservativeMode;
2917 fragDepth || fragStencil, // bool useDepthStencil;
2918 fragDepth, // bool fragDepth;
2919 fragStencil, // bool fragStencil;
2920 multiViewport, // bool multiViewport;
2921 colorLayered, // bool colorLayered;
2922 srLayered, // bool srLayered;
2923 numColorLayers, // deUint32 numColorLayers;
2924 multiView, // bool multiView;
2925 correlationMask, // bool correlationMask;
2926 interlock, // bool interlock;
2927 sampleLocations, // bool sampleLocations;
2928 sampleShadingEnable, // bool sampleShadingEnable;
2929 sampleShadingInput, // bool sampleShadingInput;
2930 false, // bool sampleMaskTest;
2931 earlyAndLateTest, // bool earlyAndLateTest;
2934 sampGroup->addChild(new FSRTestCase(testCtx, geomCases[geomNdx].name, geomCases[geomNdx].description, c));
2936 extGroup->addChild(sampGroup.release());
2938 cmb1Group->addChild(extGroup.release());
2940 cmb0Group->addChild(cmb1Group.release());
2942 shdGroup->addChild(cmb0Group.release());
2944 attGroup->addChild(shdGroup.release());
2946 dynGroup->addChild(attGroup.release());
2948 group->addChild(dynGroup.release());
2950 parentGroup->addChild(group.release());
2953 if (!groupParams->useSecondaryCmdBuffer)
2955 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "misc_tests", "Single tests that don't need to be part of above test matrix"));
2956 group->addChild(new FSRTestCase(testCtx, "sample_mask_test", "", {
2957 groupParams, // SharedGroupParams groupParams;
2958 123, // deInt32 seed;
2959 {32, 33}, // VkExtent2D framebufferDim;
2960 VK_SAMPLE_COUNT_4_BIT, // VkSampleCountFlagBits samples;
2962 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
2963 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
2964 }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
2965 AttachmentUsage::NO_ATTACHMENT, // AttachmentUsage attachmentUsage;
2966 true, // bool shaderWritesRate;
2967 false, // bool geometryShader;
2968 false, // bool useDynamicState;
2969 true, // bool useApiSampleMask;
2970 false, // bool useSampleMaskIn;
2971 false, // bool conservativeEnable;
2972 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, // VkConservativeRasterizationModeEXT conservativeMode;
2973 false, // bool useDepthStencil;
2974 false, // bool fragDepth;
2975 false, // bool fragStencil;
2976 false, // bool multiViewport;
2977 false, // bool colorLayered;
2978 false, // bool srLayered;
2979 1u, // deUint32 numColorLayers;
2980 false, // bool multiView;
2981 false, // bool correlationMask;
2982 false, // bool interlock;
2983 false, // bool sampleLocations;
2984 false, // bool sampleShadingEnable;
2985 false, // bool sampleShadingInput;
2986 true, // bool sampleMaskTest;
2987 false, // bool earlyAndLateTest;
2990 parentGroup->addChild(group.release());
2994 } // FragmentShadingRage