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"
63 namespace FragmentShadingRate
70 #define NUM_TRIANGLES (9*9)
72 enum class AttachmentUsage
82 VkExtent2D framebufferDim;
83 VkSampleCountFlagBits samples;
84 VkFragmentShadingRateCombinerOpKHR combinerOp[2];
85 AttachmentUsage attachmentUsage;
86 bool shaderWritesRate;
89 bool useApiSampleMask;
91 bool conservativeEnable;
92 VkConservativeRasterizationModeEXT conservativeMode;
93 bool useDepthStencil; // == fragDepth || fragStencil
98 bool srLayered; // colorLayered must also be true
99 deUint32 numColorLayers;
102 bool sampleLocations;
103 bool sampleShadingEnable;
104 bool sampleShadingInput;
106 bool useAttachment () const
108 return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT);
112 class FSRTestInstance : public TestInstance
115 FSRTestInstance (Context& context, const CaseDef& data);
116 ~FSRTestInstance (void);
117 tcu::TestStatus iterate (void);
123 // Cache simulated combiner operations, to avoid recomputing per-sample
124 deInt32 m_simulateValueCount;
125 vector<deInt32> m_simulateCache;
126 // Cache mapping of primitive ID to pipeline/primitive shading rate
127 vector<deInt32> m_primIDToPrimitiveShadingRate;
128 vector<deInt32> m_primIDToPipelineShadingRate;
129 deUint32 m_supportedFragmentShadingRateCount;
130 vector<VkPhysicalDeviceFragmentShadingRateKHR> m_supportedFragmentShadingRates;
131 VkPhysicalDeviceFragmentShadingRatePropertiesKHR m_shadingRateProperties;
133 deInt32 PrimIDToPrimitiveShadingRate (deInt32 primID);
134 deInt32 PrimIDToPipelineShadingRate (deInt32 primID);
135 VkExtent2D SanitizeExtent (VkExtent2D ext) const;
136 deInt32 SanitizeRate (deInt32 rate) const;
137 deInt32 ShadingRateExtentToClampedMask (VkExtent2D ext, bool allowSwap) const;
138 deInt32 ShadingRateExtentToEnum (VkExtent2D ext) const;
139 VkExtent2D ShadingRateEnumToExtent (deInt32 rate) const;
140 deInt32 Simulate (deInt32 rate0, deInt32 rate1, deInt32 rate2);
141 VkExtent2D Combine (VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const;
142 bool Force1x1 () const;
145 FSRTestInstance::FSRTestInstance (Context& context, const CaseDef& data)
146 : vkt::TestInstance (context)
148 , m_simulateValueCount (((4 * 4) | 4) + 1)
149 , m_simulateCache (m_simulateValueCount*m_simulateValueCount*m_simulateValueCount, ~0)
150 , m_primIDToPrimitiveShadingRate(NUM_TRIANGLES, ~0)
151 , m_primIDToPipelineShadingRate(NUM_TRIANGLES, ~0)
153 m_supportedFragmentShadingRateCount = 0;
154 m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, DE_NULL);
156 if (m_supportedFragmentShadingRateCount < 3)
157 TCU_THROW(TestError, "*pFragmentShadingRateCount too small");
159 m_supportedFragmentShadingRates.resize(m_supportedFragmentShadingRateCount);
160 for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
162 m_supportedFragmentShadingRates[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
163 m_supportedFragmentShadingRates[i].pNext = nullptr;
165 m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, &m_supportedFragmentShadingRates[0]);
167 m_shadingRateProperties = m_context.getFragmentShadingRateProperties();
170 FSRTestInstance::~FSRTestInstance (void)
174 class FSRTestCase : public TestCase
177 FSRTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data);
179 virtual void initPrograms (SourceCollections& programCollection) const;
180 virtual TestInstance* createInstance (Context& context) const;
181 virtual void checkSupport (Context& context) const;
187 FSRTestCase::FSRTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data)
188 : vkt::TestCase (context, name, desc)
193 FSRTestCase::~FSRTestCase (void)
197 bool FSRTestInstance::Force1x1() const
199 if (m_data.useApiSampleMask && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
202 if (m_data.useSampleMaskIn && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderSampleMask)
205 if (m_data.conservativeEnable && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithConservativeRasterization)
208 if (m_data.useDepthStencil && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderDepthStencilWrites)
211 if (m_data.interlock && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithFragmentShaderInterlock)
214 if (m_data.sampleLocations && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations)
217 if (m_data.sampleShadingEnable || m_data.sampleShadingInput)
223 static VkImageUsageFlags cbUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
224 VK_IMAGE_USAGE_SAMPLED_BIT |
225 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
226 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
228 void FSRTestCase::checkSupport(Context& context) const
230 context.requireDeviceFunctionality("VK_KHR_fragment_shading_rate");
232 if (!context.getFragmentShadingRateFeatures().pipelineFragmentShadingRate)
233 TCU_THROW(NotSupportedError, "pipelineFragmentShadingRate not supported");
235 if (m_data.shaderWritesRate &&
236 !context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate)
237 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
239 if (!context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate &&
240 m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
241 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
243 if (!context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
244 m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
245 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
247 VkImageFormatProperties imageProperties;
248 VkResult result = context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(context.getPhysicalDevice(), VK_FORMAT_R32G32B32A32_UINT, VK_IMAGE_TYPE_2D,
249 VK_IMAGE_TILING_OPTIMAL, cbUsage, 0, &imageProperties);
251 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
252 TCU_THROW(NotSupportedError, "VK_FORMAT_R32G32B32A32_UINT not supported");
254 if (!(imageProperties.sampleCounts & m_data.samples))
255 TCU_THROW(NotSupportedError, "color buffer sample count not supported");
257 if (m_data.numColorLayers > imageProperties.maxArrayLayers)
258 TCU_THROW(NotSupportedError, "color buffer layers not supported");
260 if (m_data.useAttachment() && !context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
261 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
263 if (!context.getFragmentShadingRateProperties().fragmentShadingRateNonTrivialCombinerOps &&
264 ((m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
265 (m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
266 TCU_THROW(NotSupportedError, "fragmentShadingRateNonTrivialCombinerOps not supported");
268 if (m_data.conservativeEnable)
270 context.requireDeviceFunctionality("VK_EXT_conservative_rasterization");
271 if (m_data.conservativeMode == VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT &&
272 !context.getConservativeRasterizationPropertiesEXT().primitiveUnderestimation)
273 TCU_THROW(NotSupportedError, "primitiveUnderestimation not supported");
276 if (m_data.fragStencil)
277 context.requireDeviceFunctionality("VK_EXT_shader_stencil_export");
279 if (m_data.multiViewport &&
280 !context.getFragmentShadingRateProperties().primitiveFragmentShadingRateWithMultipleViewports)
281 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRateWithMultipleViewports not supported");
283 if (m_data.srLayered &&
284 !context.getFragmentShadingRateProperties().layeredShadingRateAttachments)
285 TCU_THROW(NotSupportedError, "layeredShadingRateAttachments not supported");
287 if ((m_data.multiViewport || m_data.colorLayered) &&
288 !m_data.geometryShader)
289 context.requireDeviceFunctionality("VK_EXT_shader_viewport_index_layer");
291 if (m_data.multiView && m_data.geometryShader &&
292 !context.getMultiviewFeatures().multiviewGeometryShader)
293 TCU_THROW(NotSupportedError, "multiviewGeometryShader not supported");
295 if (m_data.interlock &&
296 !context.getFragmentShaderInterlockFeaturesEXT().fragmentShaderPixelInterlock)
297 TCU_THROW(NotSupportedError, "fragmentShaderPixelInterlock not supported");
299 if (m_data.sampleLocations)
301 context.requireDeviceFunctionality("VK_EXT_sample_locations");
302 if (!(m_data.samples & context.getSampleLocationsPropertiesEXT().sampleLocationSampleCounts))
303 TCU_THROW(NotSupportedError, "samples not supported in sampleLocationSampleCounts");
307 // Error codes writted by the fragment shader
311 ERROR_FRAGCOORD_CENTER = 1,
312 ERROR_VTG_READBACK = 2,
313 ERROR_FRAGCOORD_DERIV = 3,
314 ERROR_FRAGCOORD_IMPLICIT_DERIV = 4,
317 void FSRTestCase::initPrograms (SourceCollections& programCollection) const
319 std::stringstream vss;
322 "#version 450 core\n"
323 "#extension GL_EXT_fragment_shading_rate : enable\n"
324 "#extension GL_ARB_shader_viewport_layer_array : enable\n"
325 "layout(push_constant) uniform PC {\n"
326 " int shadingRate;\n"
328 "layout(location = 0) in vec2 pos;\n"
329 "layout(location = 0) out int instanceIndex;\n"
330 "layout(location = 1) out int readbackok;\n"
331 "layout(location = 2) out float zero;\n"
334 " vec4 gl_Position;\n"
338 " gl_Position = vec4(pos, 0, 1);\n"
339 " instanceIndex = gl_InstanceIndex;\n"
343 if (m_data.shaderWritesRate)
345 vss << " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
347 // Verify that we can read from the output variable
348 vss << " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
350 if (!m_data.geometryShader)
352 if (m_data.multiViewport)
353 vss << " gl_ViewportIndex = instanceIndex & 1;\n";
354 if (m_data.colorLayered)
355 vss << " gl_Layer = (instanceIndex & 2) >> 1;\n";
361 programCollection.glslSources.add("vert") << glu::VertexSource(vss.str());
363 if (m_data.geometryShader)
365 std::string writeShadingRate = "";
366 if (m_data.shaderWritesRate)
369 " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n"
370 " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
372 if (m_data.multiViewport)
373 writeShadingRate += " gl_ViewportIndex = inInstanceIndex[0] & 1;\n";
375 if (m_data.colorLayered)
376 writeShadingRate += " gl_Layer = (inInstanceIndex[0] & 2) >> 1;\n";
379 std::stringstream gss;
381 "#version 450 core\n"
382 "#extension GL_EXT_fragment_shading_rate : enable\n"
384 "layout(push_constant) uniform PC {\n"
385 " int shadingRate;\n"
390 " vec4 gl_Position;\n"
393 "layout(location = 0) in int inInstanceIndex[];\n"
394 "layout(location = 0) out int outInstanceIndex;\n"
395 "layout(location = 1) out int readbackok;\n"
396 "layout(location = 2) out float zero;\n"
397 "layout(triangles) in;\n"
398 "layout(triangle_strip, max_vertices=3) out;\n"
400 "out gl_PerVertex {\n"
401 " vec4 gl_Position;\n"
406 " gl_Position = gl_in[0].gl_Position;\n"
407 " outInstanceIndex = inInstanceIndex[0];\n"
410 << writeShadingRate <<
413 " gl_Position = gl_in[1].gl_Position;\n"
414 " outInstanceIndex = inInstanceIndex[1];\n"
417 << writeShadingRate <<
420 " gl_Position = gl_in[2].gl_Position;\n"
421 " outInstanceIndex = inInstanceIndex[2];\n"
424 << writeShadingRate <<
428 programCollection.glslSources.add("geom") << glu::GeometrySource(gss.str());
431 std::stringstream fss;
434 "#version 450 core\n"
435 "#extension GL_EXT_fragment_shading_rate : enable\n"
436 "#extension GL_ARB_shader_stencil_export : enable\n"
437 "#extension GL_ARB_fragment_shader_interlock : enable\n"
438 "layout(location = 0) out uvec4 col0;\n"
439 "layout(set = 0, binding = 0) buffer Block { uint counter; } buf;\n"
440 "layout(set = 0, binding = 3) uniform usampler2D tex;\n"
441 "layout(location = 0) flat in int instanceIndex;\n"
442 "layout(location = 1) flat in int readbackok;\n"
443 "layout(location = 2) " << (m_data.sampleShadingInput ? "sample " : "") << "in float zero;\n";
445 if (m_data.interlock)
446 fss << "layout(pixel_interlock_ordered) in;\n";
452 if (m_data.interlock)
453 fss << " beginInvocationInterlockARB();\n";
456 // X component gets shading rate enum
457 " col0.x = gl_ShadingRateEXT;\n"
459 // Z component gets packed primitiveID | atomic value
460 " col0.z = (instanceIndex << 24) | ((atomicAdd(buf.counter, 1) + 1) & 0x00FFFFFFu);\n"
461 " ivec2 fragCoordXY = ivec2(gl_FragCoord.xy);\n"
462 " ivec2 fragSize = ivec2(1<<((gl_ShadingRateEXT/4)&3), 1<<(gl_ShadingRateEXT&3));\n"
463 // W component gets error code
464 " col0.w = uint(zero)" << (m_data.sampleShadingInput ? " * gl_SampleID" : "") << ";\n"
465 " if (((fragCoordXY - fragSize / 2) % fragSize) != ivec2(0,0))\n"
466 " col0.w = " << ERROR_FRAGCOORD_CENTER << ";\n";
468 if (m_data.shaderWritesRate)
471 " if (readbackok != 1)\n"
472 " col0.w = " << ERROR_VTG_READBACK << ";\n";
475 // When sample shading, gl_FragCoord is more likely to give bad derivatives,
476 // e.g. due to a partially covered quad having some pixels center sample and
477 // some sample at a sample location.
478 if (!m_data.sampleShadingEnable && !m_data.sampleShadingInput)
480 fss << " if (dFdx(gl_FragCoord.xy) != ivec2(fragSize.x, 0) || dFdy(gl_FragCoord.xy) != ivec2(0, fragSize.y))\n"
481 " col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (int(dFdx(gl_FragCoord.xy)) << 14) | (int(dFdx(gl_FragCoord.xy)) << 8) | " << ERROR_FRAGCOORD_DERIV << ";\n";
483 fss << " uint implicitDerivX = texture(tex, vec2(gl_FragCoord.x / textureSize(tex, 0).x, 0)).x;\n"
484 " uint implicitDerivY = texture(tex, vec2(0, gl_FragCoord.y / textureSize(tex, 0).y)).x;\n"
485 " if (implicitDerivX != fragSize.x || implicitDerivY != fragSize.y)\n"
486 " col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (implicitDerivY << 14) | (implicitDerivX << 8) | " << ERROR_FRAGCOORD_IMPLICIT_DERIV << ";\n";
488 // Y component gets sample mask value
489 if (m_data.useSampleMaskIn)
490 fss << " col0.y = gl_SampleMaskIn[0];\n";
492 if (m_data.fragDepth)
493 fss << " gl_FragDepth = float(instanceIndex) / float(" << NUM_TRIANGLES << ");\n";
495 if (m_data.fragStencil)
496 fss << " gl_FragStencilRefARB = instanceIndex;\n";
498 if (m_data.interlock)
499 fss << " endInvocationInterlockARB();\n";
504 programCollection.glslSources.add("frag") << glu::FragmentSource(fss.str());
506 std::stringstream css;
508 std::string fsampType = m_data.samples > 1 ? "texture2DMSArray" : "texture2DArray";
509 std::string usampType = m_data.samples > 1 ? "utexture2DMSArray" : "utexture2DArray";
511 // Compute shader copies color/depth/stencil to linear layout in buffer memory
513 "#version 450 core\n"
514 "#extension GL_EXT_samplerless_texture_functions : enable\n"
515 "layout(set = 0, binding = 1) uniform " << usampType << " colorTex;\n"
516 "layout(set = 0, binding = 2, std430) buffer Block0 { uvec4 b[]; } colorbuf;\n"
517 "layout(set = 0, binding = 4, std430) buffer Block1 { float b[]; } depthbuf;\n"
518 "layout(set = 0, binding = 5, std430) buffer Block2 { uint b[]; } stencilbuf;\n"
519 "layout(set = 0, binding = 6) uniform " << fsampType << " depthTex;\n"
520 "layout(set = 0, binding = 7) uniform " << usampType << " stencilTex;\n"
521 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
524 " for (int i = 0; i < " << m_data.samples << "; ++i) {\n"
525 " uint idx = ((gl_GlobalInvocationID.z * " << m_data.framebufferDim.height << " + gl_GlobalInvocationID.y) * " << m_data.framebufferDim.width << " + gl_GlobalInvocationID.x) * " << m_data.samples << " + i;\n"
526 " colorbuf.b[idx] = texelFetch(colorTex, ivec3(gl_GlobalInvocationID.xyz), i);\n";
528 if (m_data.fragDepth)
529 css << " depthbuf.b[idx] = texelFetch(depthTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
531 if (m_data.fragStencil)
532 css << " stencilbuf.b[idx] = texelFetch(stencilTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
538 programCollection.glslSources.add("comp") << glu::ComputeSource(css.str());
541 TestInstance* FSRTestCase::createInstance (Context& context) const
543 return new FSRTestInstance(context, m_data);
546 deInt32 FSRTestInstance::ShadingRateExtentToEnum(VkExtent2D ext) const
548 ext.width = deCtz32(ext.width);
549 ext.height = deCtz32(ext.height);
551 return (ext.width << 2) | ext.height;
554 VkExtent2D FSRTestInstance::ShadingRateEnumToExtent(deInt32 rate) const
557 ret.width = 1 << ((rate/4) & 3);
558 ret.height = 1 << (rate & 3);
563 VkExtent2D FSRTestInstance::Combine(VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const
571 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
573 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR:
575 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR:
576 ret = { de::min(ext0.width, ext1.width), de::min(ext0.height, ext1.height) };
578 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR:
579 ret = { de::max(ext0.width, ext1.width), de::max(ext0.height, ext1.height) };
581 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR:
582 ret = { ext0.width * ext1.width, ext0.height * ext1.height };
583 if (!m_shadingRateProperties.fragmentShadingRateStrictMultiplyCombiner)
585 if (ext0.width == 1 && ext1.width == 1)
587 if (ext0.height == 1 && ext1.height == 1)
594 deInt32 FSRTestInstance::Simulate(deInt32 rate0, deInt32 rate1, deInt32 rate2)
596 deInt32 &cachedRate = m_simulateCache[(rate2*m_simulateValueCount + rate1)*m_simulateValueCount + rate0];
597 if (cachedRate != ~0)
600 VkExtent2D extent0 = ShadingRateEnumToExtent(rate0);
601 VkExtent2D extent1 = ShadingRateEnumToExtent(rate1);
602 VkExtent2D extent2 = ShadingRateEnumToExtent(rate2);
604 deInt32 finalMask = 0;
605 // Simulate once for implementations that don't allow swapping rate xy,
606 // and once for those that do. Any of those results is allowed.
607 for (deUint32 allowSwap = 0; allowSwap <= 1; ++allowSwap)
609 // Combine rate 0 and 1, get a mask of possible clamped rates
610 VkExtent2D intermed = Combine(extent0, extent1, m_data.combinerOp[0]);
611 deInt32 intermedMask = ShadingRateExtentToClampedMask(intermed, allowSwap == 1);
613 // For each clamped rate, combine that with rate 2 and accumulate the possible clamped rates
614 for (int i = 0; i < 16; ++i)
616 if (intermedMask & (1<<i))
618 VkExtent2D final = Combine(ShadingRateEnumToExtent(i), extent2, m_data.combinerOp[1]);
619 finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
623 // unclamped intermediate value is also permitted
624 VkExtent2D final = Combine(intermed, extent2, m_data.combinerOp[1]);
625 finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
632 cachedRate = finalMask;
636 // If a rate is not valid (<=4x4), clamp it to something valid.
637 // This is only used for "inputs" to the system, not to mimic
638 // how the implementation internally clamps intermediate values.
639 VkExtent2D FSRTestInstance::SanitizeExtent(VkExtent2D ext) const
641 DE_ASSERT(ext.width > 0 && ext.height > 0);
643 ext.width = de::min(ext.width, 4u);
644 ext.height = de::min(ext.height, 4u);
649 // Map an extent to a mask of all modes smaller than or equal to it in either dimension
650 deInt32 FSRTestInstance::ShadingRateExtentToClampedMask(VkExtent2D ext, bool allowSwap) const
652 deUint32 desiredSize = ext.width * ext.height;
656 while (desiredSize > 0)
658 // First, find modes that maximize the area
659 for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
661 const VkPhysicalDeviceFragmentShadingRateKHR &supportedRate = m_supportedFragmentShadingRates[i];
662 if ((supportedRate.sampleCounts & m_data.samples) &&
663 supportedRate.fragmentSize.width * supportedRate.fragmentSize.height == desiredSize &&
664 ((supportedRate.fragmentSize.width <= ext.width && supportedRate.fragmentSize.height <= ext.height) ||
665 (supportedRate.fragmentSize.height <= ext.width && supportedRate.fragmentSize.width <= ext.height && allowSwap)))
667 mask |= 1 << ShadingRateExtentToEnum(supportedRate.fragmentSize);
672 // Amongst the modes that maximize the area, pick the ones that
673 // minimize the aspect ratio. Prefer ratio of 1, then 2, then 4.
674 // 1x1 = 0, 2x2 = 5, 4x4 = 10
675 static const deUint32 aspectMaskRatio1 = 0x421;
676 // 2x1 = 4, 1x2 = 1, 4x2 = 9, 2x4 = 6
677 static const deUint32 aspectMaskRatio2 = 0x252;
679 static const deUint32 aspectMaskRatio4 = 0x104;
681 if (mask & aspectMaskRatio1)
683 mask &= aspectMaskRatio1;
686 if (mask & aspectMaskRatio2)
688 mask &= aspectMaskRatio2;
691 if (mask & aspectMaskRatio4)
693 mask &= aspectMaskRatio4;
705 deInt32 FSRTestInstance::SanitizeRate(deInt32 rate) const
707 VkExtent2D extent = ShadingRateEnumToExtent(rate);
709 extent = SanitizeExtent(extent);
711 return ShadingRateExtentToEnum(extent);
714 // Map primID % 9 to primitive shading rate
715 deInt32 FSRTestInstance::PrimIDToPrimitiveShadingRate(deInt32 primID)
717 deInt32 &cachedRate = m_primIDToPrimitiveShadingRate[primID];
718 if (cachedRate != ~0)
722 extent.width = 1 << (primID % 3);
723 extent.height = 1 << ((primID/3) % 3);
725 cachedRate = ShadingRateExtentToEnum(extent);
729 // Map primID / 9 to pipeline shading rate
730 deInt32 FSRTestInstance::PrimIDToPipelineShadingRate(deInt32 primID)
732 deInt32 &cachedRate = m_primIDToPipelineShadingRate[primID];
733 if (cachedRate != ~0)
738 extent.width = 1 << (primID % 3);
739 extent.height = 1 << ((primID/3) % 3);
741 cachedRate = ShadingRateExtentToEnum(extent);
745 static de::MovePtr<BufferWithMemory> CreateCachedBuffer(const vk::DeviceInterface& vk,
746 const vk::VkDevice device,
747 vk::Allocator& allocator,
748 const vk::VkBufferCreateInfo& bufferCreateInfo)
752 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
753 vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible | MemoryRequirement::Cached));
755 catch (const tcu::NotSupportedError&)
757 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
758 vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible));
762 tcu::TestStatus FSRTestInstance::iterate (void)
764 const DeviceInterface& vk = m_context.getDeviceInterface();
765 const VkDevice device = m_context.getDevice();
766 tcu::TestLog& log = m_context.getTestContext().getLog();
767 Allocator& allocator = m_context.getDefaultAllocator();
768 VkFlags allShaderStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
769 VkFlags allPipelineStages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
770 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
771 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
772 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
773 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
774 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
775 VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV;
777 if (m_data.geometryShader)
779 allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
780 allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
784 deRandom_init(&rnd, m_data.seed);
786 qpTestResult res = QP_TEST_RESULT_PASS;
787 deUint32 numUnexpected1x1Samples = 0;
788 deUint32 numTotalSamples = 0;
792 ATTACHMENT_MODE_DEFAULT = 0,
793 ATTACHMENT_MODE_LAYOUT_OPTIMAL,
794 ATTACHMENT_MODE_IMAGELESS,
795 ATTACHMENT_MODE_2DARRAY,
796 ATTACHMENT_MODE_TILING_LINEAR,
798 ATTACHMENT_MODE_COUNT,
801 deUint32 numSRLayers = m_data.srLayered ? 2u : 1u;
803 VkExtent2D minFragmentShadingRateAttachmentTexelSize = {1, 1};
804 VkExtent2D maxFragmentShadingRateAttachmentTexelSize = {1, 1};
805 deUint32 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = 1;
806 if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
808 minFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().minFragmentShadingRateAttachmentTexelSize;
809 maxFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSize;
810 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
813 VkDeviceSize atomicBufferSize = sizeof(deUint32);
815 de::MovePtr<BufferWithMemory> atomicBuffer;
816 atomicBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
817 vk, device, allocator, makeBufferCreateInfo(atomicBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
819 deUint32 *abuf = (deUint32 *)atomicBuffer->getAllocation().getHostPtr();
821 // NUM_TRIANGLES triangles, 3 vertices, 2 components of float position
822 VkDeviceSize vertexBufferSize = NUM_TRIANGLES * 3 * 2 * sizeof(float);
824 de::MovePtr<BufferWithMemory> vertexBuffer;
825 vertexBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
826 vk, device, allocator, makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
828 float *vbuf = (float *)vertexBuffer->getAllocation().getHostPtr();
829 for (deInt32 i = 0; i < (deInt32)(vertexBufferSize / sizeof(float)); ++i)
831 vbuf[i] = deRandom_getFloat(&rnd)*2.0f - 1.0f;
833 flushAlloc(vk, device, vertexBuffer->getAllocation());
835 VkDeviceSize colorOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * 4 * sizeof(deUint32) * m_data.numColorLayers;
836 de::MovePtr<BufferWithMemory> colorOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(colorOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
838 VkDeviceSize depthOutputBufferSize = 0, stencilOutputBufferSize = 0;
839 de::MovePtr<BufferWithMemory> depthOutputBuffer, stencilOutputBuffer;
840 if (m_data.useDepthStencil)
842 depthOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(float) * m_data.numColorLayers;
843 depthOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(depthOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
845 stencilOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(deUint32) * m_data.numColorLayers;
846 stencilOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(stencilOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
849 deUint32 minSRTexelWidth = minFragmentShadingRateAttachmentTexelSize.width;
850 deUint32 minSRTexelHeight = minFragmentShadingRateAttachmentTexelSize.height;
851 deUint32 maxSRWidth = (m_data.framebufferDim.width + minSRTexelWidth - 1) / minSRTexelWidth;
852 deUint32 maxSRHeight = (m_data.framebufferDim.height + minSRTexelHeight - 1) / minSRTexelHeight;
854 // max size over all formats
855 VkDeviceSize srFillBufferSize = numSRLayers * maxSRWidth * maxSRHeight * 32/*4 component 64-bit*/;
856 de::MovePtr<BufferWithMemory> srFillBuffer;
857 deUint8 *fillPtr = DE_NULL;
858 if (m_data.useAttachment())
860 srFillBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(srFillBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
861 fillPtr = (deUint8 *)srFillBuffer->getAllocation().getHostPtr();
864 const auto cbFormat = VK_FORMAT_R32G32B32A32_UINT;
865 de::MovePtr<ImageWithMemory> cbImage;
866 Move<VkImageView> cbImageView;
868 const VkImageCreateInfo imageCreateInfo =
870 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
871 DE_NULL, // const void* pNext;
872 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
873 VK_IMAGE_TYPE_2D, // VkImageType imageType;
874 cbFormat, // VkFormat format;
876 m_data.framebufferDim.width, // deUint32 width;
877 m_data.framebufferDim.height, // deUint32 height;
878 1u // deUint32 depth;
879 }, // VkExtent3D extent;
880 1u, // deUint32 mipLevels;
881 m_data.numColorLayers, // deUint32 arrayLayers;
882 m_data.samples, // VkSampleCountFlagBits samples;
883 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
884 cbUsage, // VkImageUsageFlags usage;
885 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
886 0u, // deUint32 queueFamilyIndexCount;
887 DE_NULL, // const deUint32* pQueueFamilyIndices;
888 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
890 cbImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
891 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
893 VkImageViewCreateInfo imageViewCreateInfo =
895 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
896 DE_NULL, // const void* pNext;
897 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
898 **cbImage, // VkImage image;
899 VK_IMAGE_VIEW_TYPE_2D_ARRAY, // VkImageViewType viewType;
900 cbFormat, // VkFormat format;
902 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
903 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
904 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
905 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
906 }, // VkComponentMapping components;
908 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
909 0u, // deUint32 baseMipLevel;
910 1u, // deUint32 levelCount;
911 0u, // deUint32 baseArrayLayer;
912 m_data.numColorLayers // deUint32 layerCount;
913 } // VkImageSubresourceRange subresourceRange;
915 cbImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
918 const auto dsFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
919 de::MovePtr<ImageWithMemory> dsImage;
920 Move<VkImageView> dsImageView, dImageView, sImageView;
921 VkImageUsageFlags dsUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
922 VK_IMAGE_USAGE_SAMPLED_BIT |
923 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
924 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
925 if (m_data.useDepthStencil)
927 const VkImageCreateInfo imageCreateInfo =
929 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
930 DE_NULL, // const void* pNext;
931 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
932 VK_IMAGE_TYPE_2D, // VkImageType imageType;
933 dsFormat, // VkFormat format;
935 m_data.framebufferDim.width, // deUint32 width;
936 m_data.framebufferDim.height, // deUint32 height;
937 1u // deUint32 depth;
938 }, // VkExtent3D extent;
939 1u, // deUint32 mipLevels;
940 m_data.numColorLayers, // deUint32 arrayLayers;
941 m_data.samples, // VkSampleCountFlagBits samples;
942 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
943 dsUsage, // VkImageUsageFlags usage;
944 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
945 0u, // deUint32 queueFamilyIndexCount;
946 DE_NULL, // const deUint32* pQueueFamilyIndices;
947 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
949 dsImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
950 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
952 VkImageViewCreateInfo imageViewCreateInfo =
954 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
955 DE_NULL, // const void* pNext;
956 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
957 **dsImage, // VkImage image;
958 VK_IMAGE_VIEW_TYPE_2D_ARRAY, // VkImageViewType viewType;
959 dsFormat, // VkFormat format;
961 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
962 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
963 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
964 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
965 }, // VkComponentMapping components;
967 VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
968 0u, // deUint32 baseMipLevel;
969 1u, // deUint32 levelCount;
970 0u, // deUint32 baseArrayLayer;
971 m_data.numColorLayers // deUint32 layerCount;
972 } // VkImageSubresourceRange subresourceRange;
974 dsImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
975 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
976 dImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
977 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
978 sImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
981 // Image used to test implicit derivative calculations.
982 // Filled with a value of 1<<lod.
983 de::MovePtr<ImageWithMemory> derivImage;
984 Move<VkImageView> derivImageView;
985 VkImageUsageFlags derivUsage = VK_IMAGE_USAGE_SAMPLED_BIT |
986 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
987 deUint32 derivNumLevels;
989 deUint32 maxDim = de::max(m_context.getFragmentShadingRateProperties().maxFragmentSize.width, m_context.getFragmentShadingRateProperties().maxFragmentSize.height);
990 derivNumLevels = 1 + deCtz32(maxDim);
991 const VkImageCreateInfo imageCreateInfo =
993 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
994 DE_NULL, // const void* pNext;
995 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
996 VK_IMAGE_TYPE_2D, // VkImageType imageType;
997 VK_FORMAT_R32_UINT, // VkFormat format;
999 m_context.getFragmentShadingRateProperties().maxFragmentSize.width, // deUint32 width;
1000 m_context.getFragmentShadingRateProperties().maxFragmentSize.height, // deUint32 height;
1001 1u // deUint32 depth;
1002 }, // VkExtent3D extent;
1003 derivNumLevels, // deUint32 mipLevels;
1004 1u, // deUint32 arrayLayers;
1005 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1006 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1007 derivUsage, // VkImageUsageFlags usage;
1008 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1009 0u, // deUint32 queueFamilyIndexCount;
1010 DE_NULL, // const deUint32* pQueueFamilyIndices;
1011 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1013 derivImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1014 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1016 VkImageViewCreateInfo imageViewCreateInfo =
1018 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1019 DE_NULL, // const void* pNext;
1020 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1021 **derivImage, // VkImage image;
1022 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1023 VK_FORMAT_R32_UINT, // VkFormat format;
1025 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1026 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1027 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1028 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1029 }, // VkComponentMapping components;
1031 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1032 0u, // deUint32 baseMipLevel;
1033 derivNumLevels, // deUint32 levelCount;
1034 0u, // deUint32 baseArrayLayer;
1035 1u // deUint32 layerCount;
1036 } // VkImageSubresourceRange subresourceRange;
1038 derivImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1041 // sampler used with derivImage
1042 const struct VkSamplerCreateInfo samplerInfo =
1044 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // sType
1047 VK_FILTER_NEAREST, // magFilter
1048 VK_FILTER_NEAREST, // minFilter
1049 VK_SAMPLER_MIPMAP_MODE_NEAREST, // mipmapMode
1050 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeU
1051 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeV
1052 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeW
1054 VK_FALSE, // anisotropyEnable
1055 1.0f, // maxAnisotropy
1056 DE_FALSE, // compareEnable
1057 VK_COMPARE_OP_ALWAYS, // compareOp
1059 (float)derivNumLevels, // maxLod
1060 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, // borderColor
1061 VK_FALSE, // unnormalizedCoords
1064 Move<VkSampler> sampler = createSampler(vk, device, &samplerInfo);
1066 Move<vk::VkDescriptorSetLayout> descriptorSetLayout;
1067 VkDescriptorSetLayoutCreateFlags layoutCreateFlags = 0;
1069 const VkDescriptorSetLayoutBinding bindings[] =
1073 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1074 1u, // descriptorCount
1075 allShaderStages, // stageFlags
1076 DE_NULL, // pImmutableSamplers
1080 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1081 1u, // descriptorCount
1082 allShaderStages, // stageFlags
1083 DE_NULL, // pImmutableSamplers
1087 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1088 1u, // descriptorCount
1089 allShaderStages, // stageFlags
1090 DE_NULL, // pImmutableSamplers
1094 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // descriptorType
1095 1u, // descriptorCount
1096 allShaderStages, // stageFlags
1097 DE_NULL, // pImmutableSamplers
1101 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1102 1u, // descriptorCount
1103 allShaderStages, // stageFlags
1104 DE_NULL, // pImmutableSamplers
1108 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1109 1u, // descriptorCount
1110 allShaderStages, // stageFlags
1111 DE_NULL, // pImmutableSamplers
1115 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1116 1u, // descriptorCount
1117 allShaderStages, // stageFlags
1118 DE_NULL, // pImmutableSamplers
1122 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1123 1u, // descriptorCount
1124 allShaderStages, // stageFlags
1125 DE_NULL, // pImmutableSamplers
1129 // Create a layout and allocate a descriptor set for it.
1130 const VkDescriptorSetLayoutCreateInfo setLayoutCreateInfo =
1132 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
1134 layoutCreateFlags, // flags
1135 sizeof(bindings)/sizeof(bindings[0]), // bindingCount
1136 &bindings[0] // pBindings
1139 descriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo);
1141 const VkPushConstantRange pushConstantRange =
1143 allShaderStages, // VkShaderStageFlags stageFlags;
1144 0u, // deUint32 offset;
1145 sizeof(deInt32) // deUint32 size;
1148 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1150 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
1152 (VkPipelineLayoutCreateFlags)0,
1153 1, // setLayoutCount
1154 &descriptorSetLayout.get(), // pSetLayouts
1155 1u, // pushConstantRangeCount
1156 &pushConstantRange, // pPushConstantRanges
1159 Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo, NULL);
1161 const Unique<VkShaderModule> cs (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
1163 const VkPipelineShaderStageCreateInfo csShaderCreateInfo =
1165 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1167 (VkPipelineShaderStageCreateFlags)0,
1168 VK_SHADER_STAGE_COMPUTE_BIT, // stage
1171 DE_NULL, // pSpecializationInfo
1174 const VkComputePipelineCreateInfo pipelineCreateInfo =
1176 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1179 csShaderCreateInfo, // cs
1180 *pipelineLayout, // layout
1181 (vk::VkPipeline)0, // basePipelineHandle
1182 0u, // basePipelineIndex
1184 Move<VkPipeline> computePipeline = createComputePipeline(vk, device, DE_NULL, &pipelineCreateInfo, NULL);
1186 for (deUint32 modeIdx = 0; modeIdx < ATTACHMENT_MODE_COUNT; ++modeIdx)
1188 // If we're not using an attachment, don't test all the different attachment modes
1189 if (modeIdx != ATTACHMENT_MODE_DEFAULT && !m_data.useAttachment())
1192 // Consider all uint formats possible
1193 static const VkFormat srFillFormats[] =
1196 VK_FORMAT_R8G8_UINT,
1197 VK_FORMAT_R8G8B8_UINT,
1198 VK_FORMAT_R8G8B8A8_UINT,
1200 VK_FORMAT_R16G16_UINT,
1201 VK_FORMAT_R16G16B16_UINT,
1202 VK_FORMAT_R16G16B16A16_UINT,
1204 VK_FORMAT_R32G32_UINT,
1205 VK_FORMAT_R32G32B32_UINT,
1206 VK_FORMAT_R32G32B32A32_UINT,
1208 VK_FORMAT_R64G64_UINT,
1209 VK_FORMAT_R64G64B64_UINT,
1210 VK_FORMAT_R64G64B64A64_UINT,
1212 // Only test all formats in the default mode
1213 deUint32 numFillFormats = modeIdx == ATTACHMENT_MODE_DEFAULT ? (deUint32)(sizeof(srFillFormats)/sizeof(srFillFormats[0])) : 1u;
1215 // Iterate over all supported tile sizes and formats
1216 for (deUint32 srTexelWidth = minFragmentShadingRateAttachmentTexelSize.width;
1217 srTexelWidth <= maxFragmentShadingRateAttachmentTexelSize.width;
1219 for (deUint32 srTexelHeight = minFragmentShadingRateAttachmentTexelSize.height;
1220 srTexelHeight <= maxFragmentShadingRateAttachmentTexelSize.height;
1222 for (deUint32 formatIdx = 0; formatIdx < numFillFormats; ++formatIdx)
1225 deUint32 aspectRatio = (srTexelHeight > srTexelWidth) ? (srTexelHeight / srTexelWidth) : (srTexelWidth / srTexelHeight);
1226 if (aspectRatio > maxFragmentShadingRateAttachmentTexelSizeAspectRatio)
1229 // Go through the loop only once when not using an attachment
1230 if (!m_data.useAttachment() &&
1231 (srTexelWidth != minFragmentShadingRateAttachmentTexelSize.width ||
1232 srTexelHeight != minFragmentShadingRateAttachmentTexelSize.height ||
1236 bool imagelessFB = modeIdx == ATTACHMENT_MODE_IMAGELESS;
1238 deUint32 srWidth = (m_data.framebufferDim.width + srTexelWidth - 1) / srTexelWidth;
1239 deUint32 srHeight = (m_data.framebufferDim.height + srTexelHeight - 1) / srTexelHeight;
1241 VkFormat srFormat = srFillFormats[formatIdx];
1242 deUint32 srFillBpp = tcu::getPixelSize(mapVkFormat(srFormat));
1244 VkImageLayout srLayout = modeIdx == ATTACHMENT_MODE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR : VK_IMAGE_LAYOUT_GENERAL;
1245 VkImageViewType srViewType = modeIdx == ATTACHMENT_MODE_2DARRAY ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
1246 VkImageTiling srTiling = (modeIdx == ATTACHMENT_MODE_TILING_LINEAR) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
1248 VkFormatProperties srFormatProperties;
1249 m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), srFormat, &srFormatProperties);
1250 VkFormatFeatureFlags srFormatFeatures = srTiling == VK_IMAGE_TILING_LINEAR ? srFormatProperties.linearTilingFeatures : srFormatProperties.optimalTilingFeatures;
1252 if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
1253 !(srFormatFeatures & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR))
1255 if (srFormat == VK_FORMAT_R8_UINT && srTiling == VK_IMAGE_TILING_OPTIMAL)
1257 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;
1258 res = QP_TEST_RESULT_FAIL;
1263 Move<vk::VkDescriptorPool> descriptorPool;
1264 Move<vk::VkDescriptorSet> descriptorSet;
1265 VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
1267 vk::DescriptorPoolBuilder poolBuilder;
1268 for (deInt32 i = 0; i < (deInt32)(sizeof(bindings)/sizeof(bindings[0])); ++i)
1269 poolBuilder.addType(bindings[i].descriptorType, bindings[i].descriptorCount);
1271 descriptorPool = poolBuilder.build(vk, device, poolCreateFlags, 1u);
1272 descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
1274 de::MovePtr<ImageWithMemory> srImage;
1275 Move<VkImageView> srImageView;
1276 VkImageUsageFlags srUsage = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR |
1277 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
1278 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1280 if (m_data.useAttachment())
1282 const VkImageCreateInfo imageCreateInfo =
1284 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1285 DE_NULL, // const void* pNext;
1286 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1287 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1288 srFormat, // VkFormat format;
1290 srWidth, // deUint32 width;
1291 srHeight, // deUint32 height;
1292 1u // deUint32 depth;
1293 }, // VkExtent3D extent;
1294 1u, // deUint32 mipLevels;
1295 numSRLayers, // deUint32 arrayLayers;
1296 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1297 srTiling, // VkImageTiling tiling;
1298 srUsage, // VkImageUsageFlags usage;
1299 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1300 0u, // deUint32 queueFamilyIndexCount;
1301 DE_NULL, // const deUint32* pQueueFamilyIndices;
1302 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1304 srImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1305 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1307 VkImageViewCreateInfo imageViewCreateInfo =
1309 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1310 DE_NULL, // const void* pNext;
1311 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1312 **srImage, // VkImage image;
1313 srViewType, // VkImageViewType viewType;
1314 srFormat, // VkFormat format;
1316 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1317 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1318 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1319 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1320 }, // VkComponentMapping components;
1322 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1323 0u, // deUint32 baseMipLevel;
1324 1u, // deUint32 levelCount;
1325 0u, // deUint32 baseArrayLayer;
1326 numSRLayers // deUint32 layerCount;
1327 } // VkImageSubresourceRange subresourceRange;
1329 srImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1332 VkDescriptorImageInfo imageInfo;
1333 VkDescriptorBufferInfo bufferInfo;
1335 VkWriteDescriptorSet w =
1337 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
1339 *descriptorSet, // dstSet
1340 (deUint32)0, // dstBinding
1341 0, // dstArrayElement
1342 1u, // descriptorCount
1343 bindings[0].descriptorType, // descriptorType
1344 &imageInfo, // pImageInfo
1345 &bufferInfo, // pBufferInfo
1346 DE_NULL, // pTexelBufferView
1350 flushAlloc(vk, device, atomicBuffer->getAllocation());
1352 bufferInfo = makeDescriptorBufferInfo(**atomicBuffer, 0, atomicBufferSize);
1354 w.descriptorType = bindings[0].descriptorType;
1355 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1357 imageInfo = makeDescriptorImageInfo(DE_NULL, *cbImageView, VK_IMAGE_LAYOUT_GENERAL);
1359 w.descriptorType = bindings[1].descriptorType;
1360 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1362 bufferInfo = makeDescriptorBufferInfo(**colorOutputBuffer, 0, colorOutputBufferSize);
1364 w.descriptorType = bindings[2].descriptorType;
1365 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1367 imageInfo = makeDescriptorImageInfo(*sampler, *derivImageView, VK_IMAGE_LAYOUT_GENERAL);
1369 w.descriptorType = bindings[3].descriptorType;
1370 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1372 if (m_data.useDepthStencil)
1374 bufferInfo = makeDescriptorBufferInfo(**depthOutputBuffer, 0, depthOutputBufferSize);
1376 w.descriptorType = bindings[4].descriptorType;
1377 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1379 bufferInfo = makeDescriptorBufferInfo(**stencilOutputBuffer, 0, stencilOutputBufferSize);
1381 w.descriptorType = bindings[5].descriptorType;
1382 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1384 imageInfo = makeDescriptorImageInfo(DE_NULL, *dImageView, VK_IMAGE_LAYOUT_GENERAL);
1386 w.descriptorType = bindings[6].descriptorType;
1387 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1389 imageInfo = makeDescriptorImageInfo(DE_NULL, *sImageView, VK_IMAGE_LAYOUT_GENERAL);
1391 w.descriptorType = bindings[7].descriptorType;
1392 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1395 Move<VkRenderPass> renderPass;
1396 Move<VkFramebuffer> framebuffer;
1398 std::vector<VkImageView> attachments;
1399 attachments.push_back(*cbImageView);
1400 deUint32 dsAttachmentIdx = 0, srAttachmentIdx = 0;
1401 if (m_data.useAttachment())
1403 srAttachmentIdx = (deUint32)attachments.size();
1404 attachments.push_back(*srImageView);
1406 if (m_data.useDepthStencil)
1408 dsAttachmentIdx = (deUint32)attachments.size();
1409 attachments.push_back(*dsImageView);
1412 const vk::VkAttachmentReference2 colorAttachmentReference =
1414 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1417 vk::VK_IMAGE_LAYOUT_GENERAL, // layout
1421 const vk::VkAttachmentReference2 fragmentShadingRateAttachment =
1423 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1425 srAttachmentIdx, // attachment
1430 const vk::VkAttachmentReference2 depthAttachmentReference =
1432 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1434 dsAttachmentIdx, // attachment
1435 vk::VK_IMAGE_LAYOUT_GENERAL, // layout
1439 const bool noAttachmentPtr = (m_data.attachmentUsage == AttachmentUsage::NO_ATTACHMENT_PTR);
1440 const VkFragmentShadingRateAttachmentInfoKHR shadingRateAttachmentInfo =
1442 VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, // VkStructureType sType;
1443 DE_NULL, // const void* pNext;
1444 (noAttachmentPtr ? nullptr : &fragmentShadingRateAttachment), // const VkAttachmentReference2* pFragmentShadingRateAttachment;
1445 { srTexelWidth, srTexelHeight }, // VkExtent2D shadingRateAttachmentTexelSize;
1448 const bool useAttachmentInfo = (m_data.attachmentUsage != AttachmentUsage::NO_ATTACHMENT);
1449 const VkSubpassDescription2 subpassDesc =
1451 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, // sType
1452 (useAttachmentInfo ? &shadingRateAttachmentInfo : nullptr), // pNext;
1453 (vk::VkSubpassDescriptionFlags)0, // flags
1454 vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
1455 m_data.multiView ? 0x3 : 0u, // viewMask
1457 DE_NULL, // pInputAttachments
1459 &colorAttachmentReference, // pColorAttachments
1460 DE_NULL, // pResolveAttachments
1461 m_data.useDepthStencil ? &depthAttachmentReference : DE_NULL, // depthStencilAttachment
1462 0u, // preserveCount
1463 DE_NULL, // pPreserveAttachments
1466 std::vector<VkAttachmentDescription2> attachmentDescriptions;
1467 attachmentDescriptions.push_back(
1469 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1470 DE_NULL, // const void* pNext;
1471 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1472 cbFormat, // VkFormat format;
1473 m_data.samples, // VkSampleCountFlagBits samples;
1474 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1475 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1476 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1477 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1478 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
1479 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
1482 if (m_data.useAttachment())
1483 attachmentDescriptions.push_back(
1485 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1486 DE_NULL, // const void* pNext;
1487 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1488 srFormat, // VkFormat format;
1489 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1490 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1491 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1492 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1493 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1494 srLayout, // VkImageLayout initialLayout;
1495 srLayout // VkImageLayout finalLayout;
1499 if (m_data.useDepthStencil)
1500 attachmentDescriptions.push_back(
1502 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1503 DE_NULL, // const void* pNext;
1504 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1505 dsFormat, // VkFormat format;
1506 m_data.samples, // VkSampleCountFlagBits samples;
1507 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1508 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1509 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp stencilLoadOp;
1510 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp;
1511 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
1512 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
1516 const VkRenderPassCreateInfo2 renderPassParams =
1518 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, // sType
1520 (vk::VkRenderPassCreateFlags)0,
1521 (deUint32)attachmentDescriptions.size(), // attachmentCount
1522 &attachmentDescriptions[0], // pAttachments
1524 &subpassDesc, // pSubpasses
1525 0u, // dependencyCount
1526 DE_NULL, // pDependencies
1527 0u, // correlatedViewMaskCount
1528 DE_NULL, // pCorrelatedViewMasks
1531 renderPass = createRenderPass2(vk, device, &renderPassParams);
1533 std::vector<VkFramebufferAttachmentImageInfo> framebufferAttachmentImageInfo;
1534 framebufferAttachmentImageInfo.push_back(
1536 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1537 DE_NULL, // const void* pNext;
1538 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1539 cbUsage, // VkImageUsageFlags usage;
1540 m_data.framebufferDim.width, // deUint32 width;
1541 m_data.framebufferDim.height, // deUint32 height;
1542 m_data.numColorLayers, // deUint32 layerCount;
1543 1u, // deUint32 viewFormatCount;
1544 &cbFormat, // const VkFormat* pViewFormats;
1547 if (m_data.useAttachment())
1548 framebufferAttachmentImageInfo.push_back(
1550 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1551 DE_NULL, // const void* pNext;
1552 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1553 srUsage, // VkImageUsageFlags usage;
1554 srWidth, // deUint32 width;
1555 srHeight, // deUint32 height;
1556 numSRLayers, // deUint32 layerCount;
1557 1u, // deUint32 viewFormatCount;
1558 &srFormat, // const VkFormat* pViewFormats;
1562 if (m_data.useDepthStencil)
1563 framebufferAttachmentImageInfo.push_back(
1565 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1566 DE_NULL, // const void* pNext;
1567 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1568 dsUsage, // VkImageUsageFlags usage;
1569 m_data.framebufferDim.width, // deUint32 width;
1570 m_data.framebufferDim.height, // deUint32 height;
1571 m_data.numColorLayers, // deUint32 layerCount;
1572 1u, // deUint32 viewFormatCount;
1573 &dsFormat, // const VkFormat* pViewFormats;
1577 const VkFramebufferAttachmentsCreateInfo framebufferAttachmentsCreateInfo =
1579 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, // VkStructureType sType;
1580 DE_NULL, // const void* pNext;
1581 (deUint32)framebufferAttachmentImageInfo.size(), // deUint32 attachmentImageInfoCount;
1582 &framebufferAttachmentImageInfo[0] // const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos;
1585 const vk::VkFramebufferCreateInfo framebufferParams =
1587 vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
1588 imagelessFB ? &framebufferAttachmentsCreateInfo : DE_NULL, // pNext
1589 (vk::VkFramebufferCreateFlags)(imagelessFB ? VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT : 0),
1590 *renderPass, // renderPass
1591 (deUint32)attachments.size(), // attachmentCount
1592 imagelessFB ? DE_NULL : &attachments[0], // pAttachments
1593 m_data.framebufferDim.width, // width
1594 m_data.framebufferDim.height, // height
1595 m_data.multiView ? 1 : m_data.numColorLayers, // layers
1598 framebuffer = createFramebuffer(vk, device, &framebufferParams);
1600 const VkVertexInputBindingDescription vertexBinding =
1602 0u, // deUint32 binding;
1603 sizeof(float) * 2, // deUint32 stride;
1604 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
1606 const VkVertexInputAttributeDescription vertexInputAttributeDescription =
1608 0u, // deUint32 location;
1609 0u, // deUint32 binding;
1610 VK_FORMAT_R32G32_SFLOAT, // VkFormat format;
1611 0u // deUint32 offset;
1614 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
1616 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1617 DE_NULL, // const void* pNext;
1618 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
1619 1u, // deUint32 vertexBindingDescriptionCount;
1620 &vertexBinding, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1621 1u, // deUint32 vertexAttributeDescriptionCount;
1622 &vertexInputAttributeDescription // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1625 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo =
1627 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1628 DE_NULL, // const void* pNext;
1629 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
1630 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
1631 VK_FALSE // VkBool32 primitiveRestartEnable;
1634 const VkPipelineRasterizationConservativeStateCreateInfoEXT consRastState =
1636 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, // VkStructureType sType;
1637 DE_NULL, // const void* pNext;
1638 (VkPipelineRasterizationConservativeStateCreateFlagsEXT)0, // VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
1639 m_data.conservativeMode, // VkConservativeRasterizationModeEXT conservativeRasterizationMode;
1640 0.0f, // float extraPrimitiveOverestimationSize;
1643 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
1645 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1646 m_data.conservativeEnable ? &consRastState : DE_NULL, // const void* pNext;
1647 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
1648 VK_FALSE, // VkBool32 depthClampEnable;
1649 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
1650 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1651 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
1652 VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace;
1653 VK_FALSE, // VkBool32 depthBiasEnable;
1654 0.0f, // float depthBiasConstantFactor;
1655 0.0f, // float depthBiasClamp;
1656 0.0f, // float depthBiasSlopeFactor;
1657 1.0f // float lineWidth;
1660 // Kill some bits from each AA mode
1661 VkSampleMask sampleMask = 0x7D56;
1662 VkSampleMask *pSampleMask = m_data.useApiSampleMask ? &sampleMask : DE_NULL;
1664 // All samples at pixel center. We'll validate that pixels are fully covered or uncovered.
1665 std::vector<VkSampleLocationEXT> sampleLocations(m_data.samples, { 0.5f, 0.5f });
1666 const VkSampleLocationsInfoEXT sampleLocationsInfo =
1668 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, // VkStructureType sType;
1669 DE_NULL, // const void* pNext;
1670 (VkSampleCountFlagBits)m_data.samples, // VkSampleCountFlagBits sampleLocationsPerPixel;
1671 { 1, 1 }, // VkExtent2D sampleLocationGridSize;
1672 (deUint32)m_data.samples, // uint32_t sampleLocationsCount;
1673 &sampleLocations[0], // const VkSampleLocationEXT* pSampleLocations;
1676 const VkPipelineSampleLocationsStateCreateInfoEXT pipelineSampleLocationsCreateInfo =
1678 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, // VkStructureType sType;
1679 DE_NULL, // const void* pNext;
1680 VK_TRUE, // VkBool32 sampleLocationsEnable;
1681 sampleLocationsInfo, // VkSampleLocationsInfoEXT sampleLocationsInfo;
1684 const VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo =
1686 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType
1687 m_data.sampleLocations ? &pipelineSampleLocationsCreateInfo : DE_NULL, // const void* pNext
1688 0u, // VkPipelineMultisampleStateCreateFlags flags
1689 (VkSampleCountFlagBits)m_data.samples, // VkSampleCountFlagBits rasterizationSamples
1690 (VkBool32)m_data.sampleShadingEnable, // VkBool32 sampleShadingEnable
1691 1.0f, // float minSampleShading
1692 pSampleMask, // const VkSampleMask* pSampleMask
1693 VK_FALSE, // VkBool32 alphaToCoverageEnable
1694 VK_FALSE // VkBool32 alphaToOneEnable
1697 std::vector<VkViewport> viewports;
1698 std::vector<VkRect2D> scissors;
1699 if (m_data.multiViewport)
1701 // Split the viewport into left and right halves
1702 int x0 = 0, x1 = m_data.framebufferDim.width/2, x2 = m_data.framebufferDim.width;
1704 viewports.push_back(makeViewport((float)x0, 0, (float)(x1-x0), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1705 scissors.push_back(makeRect2D(x0, 0, x1-x0, m_data.framebufferDim.height));
1707 viewports.push_back(makeViewport((float)x1, 0, (float)(x2-x1), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1708 scissors.push_back(makeRect2D(x1, 0, x2-x1, m_data.framebufferDim.height));
1712 viewports.push_back(makeViewport(m_data.framebufferDim.width, m_data.framebufferDim.height));
1713 scissors.push_back(makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height));
1716 const VkPipelineViewportStateCreateInfo viewportStateCreateInfo =
1718 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType
1719 DE_NULL, // const void* pNext
1720 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags
1721 (deUint32)viewports.size(), // deUint32 viewportCount
1722 &viewports[0], // const VkViewport* pViewports
1723 (deUint32)scissors.size(), // deUint32 scissorCount
1724 &scissors[0] // const VkRect2D* pScissors
1727 Move<VkShaderModule> fragShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0);
1728 Move<VkShaderModule> vertShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0);
1729 Move<VkShaderModule> geomShader;
1730 if (m_data.geometryShader)
1731 geomShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("geom"), 0);
1733 deUint32 numStages = m_data.geometryShader ? 3 : 2u;
1735 const VkPipelineShaderStageCreateInfo shaderCreateInfo[3] =
1738 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1740 (VkPipelineShaderStageCreateFlags)0,
1741 VK_SHADER_STAGE_VERTEX_BIT, // stage
1742 *vertShader, // shader
1744 DE_NULL, // pSpecializationInfo
1747 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1749 (VkPipelineShaderStageCreateFlags)0,
1750 VK_SHADER_STAGE_FRAGMENT_BIT, // stage
1751 *fragShader, // shader
1753 DE_NULL, // pSpecializationInfo
1756 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1758 (VkPipelineShaderStageCreateFlags)0,
1759 VK_SHADER_STAGE_GEOMETRY_BIT, // stage
1760 *geomShader, // shader
1762 DE_NULL, // pSpecializationInfo
1766 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
1768 VK_FALSE, // VkBool32 blendEnable;
1769 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor;
1770 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
1771 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
1772 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor;
1773 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
1774 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
1775 0xf // VkColorComponentFlags colorWriteMask;
1778 const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
1780 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
1781 DE_NULL, // const void* pNext;
1782 0u, // VkPipelineColorBlendStateCreateFlags flags;
1783 VK_FALSE, // VkBool32 logicOpEnable;
1784 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1785 1u, // deUint32 attachmentCount;
1786 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
1787 { 1.0f, 1.0f, 1.0f, 1.0f } // float blendConstants[4];
1790 VkPipelineFragmentShadingRateStateCreateInfoKHR shadingRateStateCreateInfo =
1792 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, // VkStructureType sType;
1793 DE_NULL, // const void* pNext;
1794 { 0, 0 }, // VkExtent2D fragmentSize;
1795 { m_data.combinerOp[0], m_data.combinerOp[1] }, // VkFragmentShadingRateCombinerOpKHR combinerOps[2];
1799 VkDynamicState dynamicState = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR;
1800 const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
1802 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
1803 DE_NULL, // const void* pNext;
1804 (VkPipelineDynamicStateCreateFlags)0, // VkPipelineDynamicStateCreateFlags flags;
1805 m_data.useDynamicState ? 1u : 0u, // uint32_t dynamicStateCount;
1806 &dynamicState, // const VkDynamicState* pDynamicStates;
1809 // Enable depth/stencil writes, always passing
1810 VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
1812 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
1813 DE_NULL, // const void* pNext;
1814 0u, // VkPipelineDepthStencilStateCreateFlags flags;
1815 VK_TRUE, // VkBool32 depthTestEnable;
1816 VK_TRUE, // VkBool32 depthWriteEnable;
1817 VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp;
1818 VK_FALSE, // VkBool32 depthBoundsTestEnable;
1819 VK_TRUE, // VkBool32 stencilTestEnable;
1820 // VkStencilOpState front;
1822 VK_STENCIL_OP_REPLACE, // VkStencilOp failOp;
1823 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
1824 VK_STENCIL_OP_REPLACE, // VkStencilOp depthFailOp;
1825 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1826 0u, // deUint32 compareMask;
1827 0xFFu, // deUint32 writeMask;
1828 0xFFu, // deUint32 reference;
1830 // VkStencilOpState back;
1832 VK_STENCIL_OP_REPLACE, // VkStencilOp failOp;
1833 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
1834 VK_STENCIL_OP_REPLACE, // VkStencilOp depthFailOp;
1835 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1836 0u, // deUint32 compareMask;
1837 0xFFu, // deUint32 writeMask;
1838 0xFFu, // deUint32 reference;
1840 0.0f, // float minDepthBounds;
1841 0.0f, // float maxDepthBounds;
1844 const VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo =
1846 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1847 &shadingRateStateCreateInfo, // const void* pNext;
1848 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1849 numStages, // deUint32 stageCount;
1850 &shaderCreateInfo[0], // const VkPipelineShaderStageCreateInfo* pStages;
1851 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1852 &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1853 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1854 &viewportStateCreateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState;
1855 &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
1856 &multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1857 &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1858 &colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1859 &dynamicStateCreateInfo, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1860 pipelineLayout.get(), // VkPipelineLayout layout;
1861 renderPass.get(), // VkRenderPass renderPass;
1862 0u, // deUint32 subpass;
1863 DE_NULL, // VkPipeline basePipelineHandle;
1864 0 // int basePipelineIndex;
1868 VkImageMemoryBarrier imageBarrier =
1870 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
1871 DE_NULL, // const void* pNext
1872 0u, // VkAccessFlags srcAccessMask
1873 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1874 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout
1875 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout newLayout
1876 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
1877 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
1878 **cbImage, // VkImage image
1880 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
1881 0u, // uint32_t baseMipLevel
1882 VK_REMAINING_MIP_LEVELS, // uint32_t mipLevels,
1883 0u, // uint32_t baseArray
1884 VK_REMAINING_ARRAY_LAYERS, // uint32_t arraySize
1888 const VkQueue queue = m_context.getUniversalQueue();
1889 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, m_context.getUniversalQueueFamilyIndex());
1890 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1892 beginCommandBuffer(vk, *cmdBuffer, 0u);
1894 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1895 (VkDependencyFlags)0,
1896 0, (const VkMemoryBarrier*)DE_NULL,
1897 0, (const VkBufferMemoryBarrier*)DE_NULL,
1900 imageBarrier.image = **derivImage;
1901 imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
1903 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1904 (VkDependencyFlags)0,
1905 0, (const VkMemoryBarrier*)DE_NULL,
1906 0, (const VkBufferMemoryBarrier*)DE_NULL,
1909 // Clear level to 1<<level
1910 for (deUint32 i = 0; i < derivNumLevels; ++i)
1912 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, i, 1u, 0u, 1u);
1913 VkClearValue clearColor = makeClearValueColorU32(1<<i,0,0,0);
1914 vk.cmdClearColorImage(*cmdBuffer, **derivImage, VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);
1917 // Clear color buffer to transparent black
1919 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
1920 VkClearValue clearColor = makeClearValueColorU32(0,0,0,0);
1922 vk.cmdClearColorImage(*cmdBuffer, **cbImage, VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);
1925 // Clear depth and stencil
1926 if (m_data.useDepthStencil)
1928 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
1929 VkClearValue clearColor = makeClearValueDepthStencil(0.0, 0);
1930 VkImageMemoryBarrier dsBarrier = imageBarrier;
1931 dsBarrier.image = **dsImage;
1932 dsBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
1933 dsBarrier.subresourceRange = range;
1934 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1935 0u, // dependencyFlags
1939 vk.cmdClearDepthStencilImage(*cmdBuffer, **dsImage, VK_IMAGE_LAYOUT_GENERAL, &clearColor.depthStencil, 1, &range);
1942 // Initialize shading rate image with varying values
1943 if (m_data.useAttachment())
1945 imageBarrier.image = **srImage;
1946 imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
1948 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1949 (VkDependencyFlags)0,
1950 0, (const VkMemoryBarrier*)DE_NULL,
1951 0, (const VkBufferMemoryBarrier*)DE_NULL,
1954 deMemset(fillPtr, 0, (size_t)srFillBufferSize);
1955 for (deUint32 layer = 0; layer < numSRLayers; ++layer)
1957 for (deUint32 x = 0; x < srWidth; ++x)
1959 for (deUint32 y = 0; y < srHeight; ++y)
1961 deUint32 idx = (layer*srHeight + y)*srWidth + x;
1962 deUint8 val = (deUint8)SanitizeRate(idx & 0xF);
1963 // actual shading rate is always in the LSBs of the first byte of a texel
1964 fillPtr[srFillBpp*idx] = val;
1968 flushAlloc(vk, device, srFillBuffer->getAllocation());
1970 const VkBufferImageCopy copyRegion =
1972 0u, // VkDeviceSize bufferOffset;
1973 0u, // deUint32 bufferRowLength;
1974 0u, // deUint32 bufferImageHeight;
1976 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspect;
1977 0u, // deUint32 mipLevel;
1978 0u, // deUint32 baseArrayLayer;
1979 numSRLayers, // deUint32 layerCount;
1980 }, // VkImageSubresourceLayers imageSubresource;
1981 { 0, 0, 0 }, // VkOffset3D imageOffset;
1982 { srWidth, srHeight, 1 }, // VkExtent3D imageExtent;
1985 vk.cmdCopyBufferToImage(*cmdBuffer, **srFillBuffer, **srImage, VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
1987 imageBarrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
1988 imageBarrier.newLayout = srLayout;
1990 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1991 (VkDependencyFlags)0,
1992 0, (const VkMemoryBarrier*)DE_NULL,
1993 0, (const VkBufferMemoryBarrier*)DE_NULL,
1997 VkMemoryBarrier memBarrier =
1999 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
2001 0u, // srcAccessMask
2002 0u, // dstAccessMask
2005 memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
2006 memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
2007 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, allPipelineStages,
2008 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2010 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0, 1, &descriptorSet.get(), 0, DE_NULL);
2012 vector<Move<VkPipeline>> pipelines;
2014 // If using dynamic state, create a single graphics pipeline and bind it
2015 if (m_data.useDynamicState)
2017 pipelines.push_back(createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo));
2018 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelines[0]);
2021 const VkRenderPassAttachmentBeginInfo renderPassAttachmentBeginInfo =
2023 VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, // VkStructureType sType;
2024 DE_NULL, // const void* pNext;
2025 (deUint32)attachments.size(), // deUint32 attachmentCount;
2026 &attachments[0] // const VkImageView* pAttachments;
2029 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer,
2030 makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height),
2031 0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE, imagelessFB ? &renderPassAttachmentBeginInfo : DE_NULL);
2033 for (deInt32 i = 0; i < NUM_TRIANGLES; ++i)
2035 // Bind vertex attributes pointing to the next triangle
2036 VkDeviceSize vertexBufferOffset = i*3*2*sizeof(float);
2037 VkBuffer vb = **vertexBuffer;
2038 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vb, &vertexBufferOffset);
2040 // Put primitive shading rate in a push constant
2041 deInt32 shadingRatePC = PrimIDToPrimitiveShadingRate(i);
2042 vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, allShaderStages, 0, sizeof(shadingRatePC), &shadingRatePC);
2044 if (m_data.useDynamicState)
2046 VkExtent2D fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2047 vk.cmdSetFragmentShadingRateKHR(*cmdBuffer, &fragmentSize, m_data.combinerOp);
2051 // Create a new pipeline with the desired pipeline shading rate
2052 shadingRateStateCreateInfo.fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2053 pipelines.push_back(createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo));
2054 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelines.back());
2057 // Draw one triangle, with "primitive ID" in gl_InstanceIndex
2058 vk.cmdDraw(*cmdBuffer, 3u, 1, 0u, i);
2061 endRenderPass(vk, *cmdBuffer);
2063 memBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
2064 memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
2065 vk.cmdPipelineBarrier(*cmdBuffer, allPipelineStages, allPipelineStages,
2066 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2068 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1, &*descriptorSet, 0u, DE_NULL);
2069 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline);
2071 // Copy color/depth/stencil buffers to buffer memory
2072 vk.cmdDispatch(*cmdBuffer, m_data.framebufferDim.width, m_data.framebufferDim.height, m_data.numColorLayers);
2074 memBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
2075 memBarrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
2076 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
2077 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2079 endCommandBuffer(vk, *cmdBuffer);
2081 submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
2083 deUint32 *colorptr = (deUint32 *)colorOutputBuffer->getAllocation().getHostPtr();
2084 invalidateAlloc(vk, device, colorOutputBuffer->getAllocation());
2086 invalidateAlloc(vk, device, atomicBuffer->getAllocation());
2088 float *depthptr = DE_NULL;
2089 deUint32 *stencilptr = DE_NULL;
2091 if (m_data.useDepthStencil)
2093 depthptr = (float *)depthOutputBuffer->getAllocation().getHostPtr();
2094 invalidateAlloc(vk, device, depthOutputBuffer->getAllocation());
2096 stencilptr = (deUint32 *)stencilOutputBuffer->getAllocation().getHostPtr();
2097 invalidateAlloc(vk, device, stencilOutputBuffer->getAllocation());
2100 // Loop over all samples and validate the output
2101 for (deUint32 layer = 0; layer < m_data.numColorLayers && res == QP_TEST_RESULT_PASS; ++layer)
2103 for (deUint32 y = 0; y < m_data.framebufferDim.height && res == QP_TEST_RESULT_PASS; ++y)
2105 for (deUint32 x = 0; x < m_data.framebufferDim.width && res == QP_TEST_RESULT_PASS; ++x)
2107 for (deInt32 s = 0; s < m_data.samples && res == QP_TEST_RESULT_PASS; ++s)
2109 deUint32 *sample = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2111 // If testing the rasterizer sample mask, if this sample is not set in the
2112 // mask then it shouldn't have written anything.
2113 if (m_data.useApiSampleMask && !(sampleMask & (1 << s)) && sample[2] != 0)
2115 log << tcu::TestLog::Message << std::hex << "sample written despite pSampleMask (" << x << "," << y << ",sample " << s << ")" << tcu::TestLog::EndMessage;
2116 res = QP_TEST_RESULT_FAIL;
2120 // The same isn't covered by any primitives, skip it
2124 // skip samples that have the same value as sample zero - it would be redundant to check them.
2127 deUint32 *sample0 = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0)];
2128 bool same = deMemCmp(sample, sample0, 16) == 0;
2130 if (m_data.fragDepth)
2132 float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2133 float *dsample0 = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2134 same = same && (*dsample == *dsample0);
2137 if (m_data.fragStencil)
2139 deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2140 deUint32 *ssample0 = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2141 same = same && (*ssample == *ssample0);
2148 // Fragment shader writes error codes to .w component.
2149 // All nonzero values are unconditionally failures
2152 if (sample[3] == ERROR_FRAGCOORD_CENTER)
2153 log << tcu::TestLog::Message << std::hex << "fragcoord test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2154 else if (sample[3] == ERROR_VTG_READBACK)
2155 log << tcu::TestLog::Message << std::hex << "vs/gs output readback test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2156 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_DERIV)
2157 log << tcu::TestLog::Message << std::hex << "fragcoord derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2158 "(0x" << ((sample[3] >> 8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2159 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2160 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_IMPLICIT_DERIV)
2161 log << tcu::TestLog::Message << std::hex << "implicit derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2162 "(0x" << ((sample[3] >> 8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2163 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2165 log << tcu::TestLog::Message << std::hex << "w coord unknown test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2166 res = QP_TEST_RESULT_FAIL;
2170 // x component of sample
2171 deUint32 rate = sample[0];
2173 deUint32 pixelsX = 1 << ((rate/4)&3);
2174 deUint32 pixelsY = 1 << (rate&3);
2177 deUint32 fragMinX = x & ~(pixelsX-1);
2178 deUint32 fragMinY = y & ~(pixelsY-1);
2179 deUint32 fragMaxX = fragMinX + pixelsX;
2180 deUint32 fragMaxY = fragMinY + pixelsY;
2182 // Clamp to FB dimension for odd sizes
2183 if (fragMaxX > m_data.framebufferDim.width)
2184 fragMaxX = m_data.framebufferDim.width;
2185 if (fragMaxY > m_data.framebufferDim.height)
2186 fragMaxY = m_data.framebufferDim.height;
2188 // z component of sample
2189 deUint32 primID = sample[2] >> 24;
2190 deUint32 atomVal = sample[2] & 0xFFFFFF;
2192 // Compute pipeline and primitive rate from primitive ID, and attachment
2193 // rate from the x/y coordinate
2194 deInt32 pipelineRate = PrimIDToPipelineShadingRate(primID);
2195 deInt32 primitiveRate = m_data.shaderWritesRate ? PrimIDToPrimitiveShadingRate(primID) : 0;
2197 deInt32 attachmentLayer = m_data.srLayered ? layer : 0;
2198 deInt32 attachmentRate = m_data.useAttachment() ? fillPtr[srFillBpp*((attachmentLayer * srHeight + (y / srTexelHeight)) * srWidth + (x / srTexelWidth))] : 0;
2200 // Get mask of allowed shading rates
2201 deInt32 expectedMasks = Simulate(pipelineRate, primitiveRate, attachmentRate);
2203 if (!(expectedMasks & (1 << rate)))
2205 log << tcu::TestLog::Message << std::hex << "unexpected shading rate. failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ") "
2206 "result rate 0x" << rate << " mask of expected rates 0x" << expectedMasks <<
2207 " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate << tcu::TestLog::EndMessage;
2208 res = QP_TEST_RESULT_FAIL;
2211 // Check that not all fragments are downgraded to 1x1
2212 if (rate == 0 && expectedMasks != 1)
2213 numUnexpected1x1Samples++;
2216 // Check that gl_FragDepth = primID / NUM_TRIANGLES
2217 if (m_data.fragDepth)
2219 float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2220 float expected = (float)primID / NUM_TRIANGLES;
2221 if (fabs(*dsample - expected) > 0.01)
2223 log << tcu::TestLog::Message << std::hex << "depth write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *dsample << " expected " << expected << tcu::TestLog::EndMessage;
2224 res = QP_TEST_RESULT_FAIL;
2229 // Check that stencil value = primID
2230 if (m_data.fragStencil)
2232 deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2233 if (*ssample != primID)
2235 log << tcu::TestLog::Message << std::hex << "stencil write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *ssample << " expected " << primID << tcu::TestLog::EndMessage;
2236 res = QP_TEST_RESULT_FAIL;
2241 // Check that primitives are in the right viewport/scissor
2242 if (m_data.multiViewport)
2244 VkRect2D *scissor = &scissors[primID & 1];
2245 if ((int)x < scissor->offset.x || (int)x >= (int)(scissor->offset.x + scissor->extent.width) ||
2246 (int)y < scissor->offset.y || (int)y >= (int)(scissor->offset.y + scissor->extent.height))
2248 log << tcu::TestLog::Message << std::hex << "primitive found outside of expected viewport (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << tcu::TestLog::EndMessage;
2249 res = QP_TEST_RESULT_FAIL;
2254 // Check that primitives are in the right layer
2255 if (m_data.colorLayered)
2257 if (layer != ((primID & 2)>>1))
2259 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;
2260 res = QP_TEST_RESULT_FAIL;
2265 // Check that multiview broadcasts the same primitive to both layers
2266 if (m_data.multiView)
2268 deUint32 otherLayer = layer^1;
2269 deUint32 *othersample = &colorptr[4*(((otherLayer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2270 deUint32 otherPrimID = othersample[2] >> 24;
2271 if (primID != otherPrimID)
2273 log << tcu::TestLog::Message << std::hex << "multiview primitive mismatch (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << " otherPrimID=" << otherPrimID << tcu::TestLog::EndMessage;
2274 res = QP_TEST_RESULT_FAIL;
2279 // Loop over all samples in the same fragment
2280 for (deUint32 fx = fragMinX; fx < fragMaxX; ++fx)
2282 for (deUint32 fy = fragMinY; fy < fragMaxY; ++fy)
2284 for (deInt32 fs = 0; fs < m_data.samples; ++fs)
2286 deUint32 *fsample = &colorptr[4*(((layer * m_data.framebufferDim.height + fy) * m_data.framebufferDim.width + fx)*m_data.samples + fs)];
2287 deUint32 frate = fsample[0];
2288 deUint32 fprimID = fsample[2] >> 24;
2289 deUint32 fatomVal = fsample[2] & 0xFFFFFF;
2291 // If we write out the sample mask value, check that the samples in the
2292 // mask must not be uncovered, and that samples not in the mask must not
2293 // be covered by this primitive
2294 if (m_data.useSampleMaskIn)
2296 int p = pixelsX * pixelsY - ((fx - fragMinX) + pixelsX * (fy - fragMinY)) - 1;
2297 int sampleIdx = fs + m_data.samples * p;
2299 if ((sample[1] & (1 << sampleIdx)) && fsample[2] == 0)
2301 log << tcu::TestLog::Message << std::hex << "sample set in sampleMask but not written (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2302 res = QP_TEST_RESULT_FAIL;
2305 if (!(sample[1] & (1 << sampleIdx)) && fsample[2] != 0 && fprimID == primID)
2307 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;
2308 res = QP_TEST_RESULT_FAIL;
2313 // If conservative raster is enabled, or custom sample locations all at the center, check that
2314 // samples in the same pixel must be covered.
2315 if (m_data.conservativeEnable ||
2316 (m_data.sampleLocations && m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations))
2318 // If it's in the same pixel, expect it to be fully covered.
2319 if (fx == x && fy == y && fsample[2] == 0)
2321 log << tcu::TestLog::Message << std::hex << "pixel not fully covered (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2322 res = QP_TEST_RESULT_FAIL;
2327 if (fsample[2] == 0)
2330 // If the primitive matches this sample, then it must have the same rate and
2332 if (fprimID == primID)
2334 if (rate != frate || (atomVal != fatomVal && !(m_data.sampleShadingEnable || m_data.sampleShadingInput)))
2336 log << tcu::TestLog::Message << std::hex << "failed pixel (0x" << x << ",0x" << y << ",sample " << s << ")=0x" << ((primID<<24)|atomVal) <<
2337 " compared to (0x" << fx << ",0x" << fy << ",sample " << fs << ")=0x" << ((fprimID<<24)|fatomVal) <<
2338 " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate <<
2339 tcu::TestLog::EndMessage;
2340 res = QP_TEST_RESULT_FAIL;
2350 if (res == QP_TEST_RESULT_FAIL)
2354 // All samples were coerced to 1x1, unexpected
2355 if (res == QP_TEST_RESULT_PASS &&
2356 numTotalSamples != 0 &&
2357 numUnexpected1x1Samples == numTotalSamples &&
2358 numTotalSamples > 16)
2360 log << tcu::TestLog::Message << std::hex << "Quality warning - all fragments used 1x1" << tcu::TestLog::EndMessage;
2361 res = QP_TEST_RESULT_QUALITY_WARNING;
2364 return tcu::TestStatus(res, qpGetTestResultName(res));
2369 void createBasicTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* parentGroup)
2375 const char* description;
2382 const char* description;
2387 AttachmentUsage usage;
2389 const char* description;
2390 } TestGroupUsageCase;
2392 TestGroupCase groupCases[] =
2394 { 0, "basic", "basic tests" },
2395 { 1, "apisamplemask", "use pSampleMask" },
2396 { 2, "samplemaskin", "use gl_SampleMaskIn" },
2397 { 3, "conservativeunder", "conservative underestimation" },
2398 { 4, "conservativeover", "conservative overestimation" },
2399 { 5, "fragdepth", "depth shader output" },
2400 { 6, "fragstencil", "stencil shader output" },
2401 { 7, "multiviewport", "multiple viewports and gl_ViewportIndex" },
2402 { 8, "colorlayered", "multiple layer color, single layer shading rate" },
2403 { 9, "srlayered", "multiple layer color, multiple layers shading rate" },
2404 { 10, "multiview", "multiview" },
2405 { 11, "multiviewsrlayered", "multiview and multilayer shading rate" },
2406 { 12, "interlock", "fragment shader interlock" },
2407 { 13, "samplelocations", "custom sample locations" },
2408 { 14, "sampleshadingenable", "enable sample shading in createinfo" },
2409 { 15, "sampleshadinginput", "enable sample shading by using gl_SampleID" },
2412 TestGroupCase dynCases[] =
2414 { 1, "dynamic", "uses dynamic shading rate state" },
2415 { 0, "static", "uses static shading rate state" },
2418 TestGroupUsageCase attCases[] =
2420 { AttachmentUsage::NO_ATTACHMENT, "noattachment", "no shading rate attachment" },
2421 { AttachmentUsage::WITH_ATTACHMENT, "attachment", "has shading rate attachment" },
2422 { AttachmentUsage::NO_ATTACHMENT_PTR, "noattachmentptr", "no shading rate attachment pointer" },
2425 TestGroupCase shdCases[] =
2427 { 0, "noshaderrate", "shader doesn't write rate" },
2428 { 1, "shaderrate", "shader writes rate" },
2431 TestGroupCase combCases[] =
2433 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, "keep", "keep" },
2434 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR, "replace", "replace" },
2435 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, "min", "min" },
2436 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, "max", "max" },
2437 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR, "mul", "mul" },
2440 TestGroupCase2D extentCases[] =
2442 { {1, 1}, "1x1", "1x1" },
2443 { {4, 4}, "4x4", "4x4" },
2444 { {33, 35}, "33x35", "33x35" },
2445 { {151, 431}, "151x431", "151x431" },
2446 { {256, 256}, "256x256", "256x256" },
2449 TestGroupCase sampCases[] =
2451 { VK_SAMPLE_COUNT_1_BIT, "samples1", "1 raster sample" },
2452 { VK_SAMPLE_COUNT_2_BIT, "samples2", "2 raster samples" },
2453 { VK_SAMPLE_COUNT_4_BIT, "samples4", "4 raster samples" },
2454 { VK_SAMPLE_COUNT_8_BIT, "samples8", "8 raster samples" },
2455 { VK_SAMPLE_COUNT_16_BIT, "samples16", "16 raster samples" },
2458 TestGroupCase geomCases[] =
2460 { 0, "vs", "vertex shader only" },
2461 { 1, "gs", "vertex and geometry shader" },
2466 for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(groupCases); groupNdx++)
2468 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, groupCases[groupNdx].name, groupCases[groupNdx].description));
2469 for (int dynNdx = 0; dynNdx < DE_LENGTH_OF_ARRAY(dynCases); dynNdx++)
2471 de::MovePtr<tcu::TestCaseGroup> dynGroup(new tcu::TestCaseGroup(testCtx, dynCases[dynNdx].name, dynCases[dynNdx].description));
2472 for (int attNdx = 0; attNdx < DE_LENGTH_OF_ARRAY(attCases); attNdx++)
2474 de::MovePtr<tcu::TestCaseGroup> attGroup(new tcu::TestCaseGroup(testCtx, attCases[attNdx].name, attCases[attNdx].description));
2475 for (int shdNdx = 0; shdNdx < DE_LENGTH_OF_ARRAY(shdCases); shdNdx++)
2477 de::MovePtr<tcu::TestCaseGroup> shdGroup(new tcu::TestCaseGroup(testCtx, shdCases[shdNdx].name, shdCases[shdNdx].description));
2478 for (int cmb0Ndx = 0; cmb0Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb0Ndx++)
2480 de::MovePtr<tcu::TestCaseGroup> cmb0Group(new tcu::TestCaseGroup(testCtx, combCases[cmb0Ndx].name, combCases[cmb0Ndx].description));
2481 for (int cmb1Ndx = 0; cmb1Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb1Ndx++)
2483 de::MovePtr<tcu::TestCaseGroup> cmb1Group(new tcu::TestCaseGroup(testCtx, combCases[cmb1Ndx].name, combCases[cmb1Ndx].description));
2484 for (int extNdx = 0; extNdx < DE_LENGTH_OF_ARRAY(extentCases); extNdx++)
2486 de::MovePtr<tcu::TestCaseGroup> extGroup(new tcu::TestCaseGroup(testCtx, extentCases[extNdx].name, extentCases[extNdx].description));
2487 for (int sampNdx = 0; sampNdx < DE_LENGTH_OF_ARRAY(sampCases); sampNdx++)
2489 de::MovePtr<tcu::TestCaseGroup> sampGroup(new tcu::TestCaseGroup(testCtx, sampCases[sampNdx].name, sampCases[sampNdx].description));
2490 for (int geomNdx = 0; geomNdx < DE_LENGTH_OF_ARRAY(geomCases); geomNdx++)
2492 bool useApiSampleMask = groupNdx == 1;
2493 bool useSampleMaskIn = groupNdx == 2;
2494 bool consRast = groupNdx == 3 || groupNdx == 4;
2495 bool fragDepth = groupNdx == 5;
2496 bool fragStencil = groupNdx == 6;
2497 bool multiViewport = groupNdx == 7;
2498 bool colorLayered = groupNdx == 8 || groupNdx == 9;
2499 bool srLayered = groupNdx == 9 || groupNdx == 11;
2500 bool multiView = groupNdx == 10 || groupNdx == 11;
2501 bool interlock = groupNdx == 12;
2502 bool sampleLocations = groupNdx == 13;
2503 bool sampleShadingEnable = groupNdx == 14;
2504 bool sampleShadingInput = groupNdx == 15;
2505 VkConservativeRasterizationModeEXT conservativeMode = (groupNdx == 3) ? VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT : VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT;
2506 deUint32 numColorLayers = (colorLayered || multiView) ? 2u : 1u;
2508 // Don't bother with geometry shader if we're not testing shader writes
2509 if (geomCases[geomNdx].count && !shdCases[shdNdx].count)
2512 // reduce number of tests
2513 if ((groupNdx != 0) &&
2514 (!dynCases[dynNdx].count ||
2515 !(combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
2516 !(combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
2519 // Don't bother with geometry shader if we're testing conservative raster, sample mask, depth/stencil
2520 if (geomCases[geomNdx].count && (useApiSampleMask || useSampleMaskIn || consRast || fragDepth || fragStencil))
2523 // Don't bother with geometry shader if we're testing non-dynamic state
2524 if (geomCases[geomNdx].count && !dynCases[dynNdx].count)
2527 // Only test multiViewport/layered with shaderWritesRate
2528 if ((multiViewport || colorLayered) && !shdCases[shdNdx].count)
2531 // Can't test layered shading rate attachment without an attachment
2532 if (srLayered && attCases[attNdx].usage != AttachmentUsage::WITH_ATTACHMENT)
2537 seed++, // deInt32 seed;
2538 extentCases[extNdx].count, // VkExtent2D framebufferDim;
2539 (VkSampleCountFlagBits)sampCases[sampNdx].count, // VkSampleCountFlagBits samples;
2541 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb0Ndx].count,
2542 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb1Ndx].count
2543 }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
2544 attCases[attNdx].usage, // AttachmentUsage attachmentUsage;
2545 (bool)shdCases[shdNdx].count, // bool shaderWritesRate;
2546 (bool)geomCases[geomNdx].count, // bool geometryShader;
2547 (bool)dynCases[dynNdx].count, // bool useDynamicState;
2548 useApiSampleMask, // bool useApiSampleMask;
2549 useSampleMaskIn, // bool useSampleMaskIn;
2550 consRast, // bool conservativeEnable;
2551 conservativeMode, // VkConservativeRasterizationModeEXT conservativeMode;
2552 fragDepth || fragStencil, // bool useDepthStencil;
2553 fragDepth, // bool fragDepth;
2554 fragStencil, // bool fragStencil;
2555 multiViewport, // bool multiViewport;
2556 colorLayered, // bool colorLayered;
2557 srLayered, // bool srLayered;
2558 numColorLayers, // deUint32 numColorLayers;
2559 multiView, // bool multiView;
2560 interlock, // bool interlock;
2561 sampleLocations, // bool sampleLocations;
2562 sampleShadingEnable, // bool sampleShadingEnable;
2563 sampleShadingInput, // bool sampleShadingInput;
2566 sampGroup->addChild(new FSRTestCase(testCtx, geomCases[geomNdx].name, geomCases[geomNdx].description, c));
2568 extGroup->addChild(sampGroup.release());
2570 cmb1Group->addChild(extGroup.release());
2572 cmb0Group->addChild(cmb1Group.release());
2574 shdGroup->addChild(cmb0Group.release());
2576 attGroup->addChild(shdGroup.release());
2578 dynGroup->addChild(attGroup.release());
2580 group->addChild(dynGroup.release());
2582 parentGroup->addChild(group.release());
2586 } // FragmentShadingRage