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;
107 bool useAttachment () const
109 return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT);
113 class FSRTestInstance : public TestInstance
116 FSRTestInstance (Context& context, const CaseDef& data);
117 ~FSRTestInstance (void);
118 tcu::TestStatus iterate (void);
124 // Cache simulated combiner operations, to avoid recomputing per-sample
125 deInt32 m_simulateValueCount;
126 vector<deInt32> m_simulateCache;
127 // Cache mapping of primitive ID to pipeline/primitive shading rate
128 vector<deInt32> m_primIDToPrimitiveShadingRate;
129 vector<deInt32> m_primIDToPipelineShadingRate;
130 deUint32 m_supportedFragmentShadingRateCount;
131 vector<VkPhysicalDeviceFragmentShadingRateKHR> m_supportedFragmentShadingRates;
132 VkPhysicalDeviceFragmentShadingRatePropertiesKHR m_shadingRateProperties;
134 deInt32 PrimIDToPrimitiveShadingRate (deInt32 primID);
135 deInt32 PrimIDToPipelineShadingRate (deInt32 primID);
136 VkExtent2D SanitizeExtent (VkExtent2D ext) const;
137 deInt32 SanitizeRate (deInt32 rate) const;
138 deInt32 ShadingRateExtentToClampedMask (VkExtent2D ext, bool allowSwap) const;
139 deInt32 ShadingRateExtentToEnum (VkExtent2D ext) const;
140 VkExtent2D ShadingRateEnumToExtent (deInt32 rate) const;
141 deInt32 Simulate (deInt32 rate0, deInt32 rate1, deInt32 rate2);
142 VkExtent2D Combine (VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const;
143 bool Force1x1 () const;
146 FSRTestInstance::FSRTestInstance (Context& context, const CaseDef& data)
147 : vkt::TestInstance (context)
149 , m_simulateValueCount (((4 * 4) | 4) + 1)
150 , m_simulateCache (m_simulateValueCount*m_simulateValueCount*m_simulateValueCount, ~0)
151 , m_primIDToPrimitiveShadingRate(NUM_TRIANGLES, ~0)
152 , m_primIDToPipelineShadingRate(NUM_TRIANGLES, ~0)
154 m_supportedFragmentShadingRateCount = 0;
155 m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, DE_NULL);
157 if (m_supportedFragmentShadingRateCount < 3)
158 TCU_THROW(TestError, "*pFragmentShadingRateCount too small");
160 m_supportedFragmentShadingRates.resize(m_supportedFragmentShadingRateCount);
161 for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
163 m_supportedFragmentShadingRates[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
164 m_supportedFragmentShadingRates[i].pNext = nullptr;
166 m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, &m_supportedFragmentShadingRates[0]);
168 m_shadingRateProperties = m_context.getFragmentShadingRateProperties();
171 FSRTestInstance::~FSRTestInstance (void)
175 class FSRTestCase : public TestCase
178 FSRTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data);
180 virtual void initPrograms (SourceCollections& programCollection) const;
181 virtual TestInstance* createInstance (Context& context) const;
182 virtual void checkSupport (Context& context) const;
188 FSRTestCase::FSRTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data)
189 : vkt::TestCase (context, name, desc)
194 FSRTestCase::~FSRTestCase (void)
198 bool FSRTestInstance::Force1x1() const
200 if (m_data.useApiSampleMask && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
203 if (m_data.useSampleMaskIn && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderSampleMask)
206 if (m_data.conservativeEnable && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithConservativeRasterization)
209 if (m_data.useDepthStencil && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderDepthStencilWrites)
212 if (m_data.interlock && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithFragmentShaderInterlock)
215 if (m_data.sampleLocations && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations)
218 if (m_data.sampleShadingEnable || m_data.sampleShadingInput)
224 static VkImageUsageFlags cbUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
225 VK_IMAGE_USAGE_SAMPLED_BIT |
226 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
227 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
229 void FSRTestCase::checkSupport(Context& context) const
231 context.requireDeviceFunctionality("VK_KHR_fragment_shading_rate");
233 if (!context.getFragmentShadingRateFeatures().pipelineFragmentShadingRate)
234 TCU_THROW(NotSupportedError, "pipelineFragmentShadingRate not supported");
236 if (m_data.shaderWritesRate &&
237 !context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate)
238 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
240 if (!context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate &&
241 m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
242 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
244 if (!context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
245 m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
246 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
248 VkImageFormatProperties imageProperties;
249 VkResult result = context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(context.getPhysicalDevice(), VK_FORMAT_R32G32B32A32_UINT, VK_IMAGE_TYPE_2D,
250 VK_IMAGE_TILING_OPTIMAL, cbUsage, 0, &imageProperties);
252 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
253 TCU_THROW(NotSupportedError, "VK_FORMAT_R32G32B32A32_UINT not supported");
255 if (!(imageProperties.sampleCounts & m_data.samples))
256 TCU_THROW(NotSupportedError, "color buffer sample count not supported");
258 if (m_data.numColorLayers > imageProperties.maxArrayLayers)
259 TCU_THROW(NotSupportedError, "color buffer layers not supported");
261 if (m_data.useAttachment() && !context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
262 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
264 if (!context.getFragmentShadingRateProperties().fragmentShadingRateNonTrivialCombinerOps &&
265 ((m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
266 (m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
267 TCU_THROW(NotSupportedError, "fragmentShadingRateNonTrivialCombinerOps not supported");
269 if (m_data.conservativeEnable)
271 context.requireDeviceFunctionality("VK_EXT_conservative_rasterization");
272 if (m_data.conservativeMode == VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT &&
273 !context.getConservativeRasterizationPropertiesEXT().primitiveUnderestimation)
274 TCU_THROW(NotSupportedError, "primitiveUnderestimation not supported");
277 if (m_data.fragStencil)
278 context.requireDeviceFunctionality("VK_EXT_shader_stencil_export");
280 if (m_data.multiViewport &&
281 !context.getFragmentShadingRateProperties().primitiveFragmentShadingRateWithMultipleViewports)
282 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRateWithMultipleViewports not supported");
284 if (m_data.srLayered &&
285 !context.getFragmentShadingRateProperties().layeredShadingRateAttachments)
286 TCU_THROW(NotSupportedError, "layeredShadingRateAttachments not supported");
288 if ((m_data.multiViewport || m_data.colorLayered) &&
289 !m_data.geometryShader)
290 context.requireDeviceFunctionality("VK_EXT_shader_viewport_index_layer");
292 if (m_data.multiView && m_data.geometryShader &&
293 !context.getMultiviewFeatures().multiviewGeometryShader)
294 TCU_THROW(NotSupportedError, "multiviewGeometryShader not supported");
296 if (m_data.interlock &&
297 !context.getFragmentShaderInterlockFeaturesEXT().fragmentShaderPixelInterlock)
298 TCU_THROW(NotSupportedError, "fragmentShaderPixelInterlock not supported");
300 if (m_data.sampleLocations)
302 context.requireDeviceFunctionality("VK_EXT_sample_locations");
303 if (!(m_data.samples & context.getSampleLocationsPropertiesEXT().sampleLocationSampleCounts))
304 TCU_THROW(NotSupportedError, "samples not supported in sampleLocationSampleCounts");
307 if (m_data.sampleMaskTest && !context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
308 TCU_THROW(NotSupportedError, "fragmentShadingRateWithSampleMask not supported");
311 // Error codes writted by the fragment shader
315 ERROR_FRAGCOORD_CENTER = 1,
316 ERROR_VTG_READBACK = 2,
317 ERROR_FRAGCOORD_DERIV = 3,
318 ERROR_FRAGCOORD_IMPLICIT_DERIV = 4,
321 void FSRTestCase::initPrograms (SourceCollections& programCollection) const
323 std::stringstream vss;
326 "#version 450 core\n"
327 "#extension GL_EXT_fragment_shading_rate : enable\n"
328 "#extension GL_ARB_shader_viewport_layer_array : enable\n"
329 "layout(push_constant) uniform PC {\n"
330 " int shadingRate;\n"
332 "layout(location = 0) in vec2 pos;\n"
333 "layout(location = 0) out int instanceIndex;\n"
334 "layout(location = 1) out int readbackok;\n"
335 "layout(location = 2) out float zero;\n"
338 " vec4 gl_Position;\n"
342 " gl_Position = vec4(pos, 0, 1);\n"
343 " instanceIndex = gl_InstanceIndex;\n"
347 if (m_data.shaderWritesRate)
349 vss << " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
351 // Verify that we can read from the output variable
352 vss << " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
354 if (!m_data.geometryShader)
356 if (m_data.multiViewport)
357 vss << " gl_ViewportIndex = instanceIndex & 1;\n";
358 if (m_data.colorLayered)
359 vss << " gl_Layer = (instanceIndex & 2) >> 1;\n";
365 programCollection.glslSources.add("vert") << glu::VertexSource(vss.str());
367 if (m_data.geometryShader)
369 std::string writeShadingRate = "";
370 if (m_data.shaderWritesRate)
373 " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n"
374 " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
376 if (m_data.multiViewport)
377 writeShadingRate += " gl_ViewportIndex = inInstanceIndex[0] & 1;\n";
379 if (m_data.colorLayered)
380 writeShadingRate += " gl_Layer = (inInstanceIndex[0] & 2) >> 1;\n";
383 std::stringstream gss;
385 "#version 450 core\n"
386 "#extension GL_EXT_fragment_shading_rate : enable\n"
388 "layout(push_constant) uniform PC {\n"
389 " int shadingRate;\n"
394 " vec4 gl_Position;\n"
397 "layout(location = 0) in int inInstanceIndex[];\n"
398 "layout(location = 0) out int outInstanceIndex;\n"
399 "layout(location = 1) out int readbackok;\n"
400 "layout(location = 2) out float zero;\n"
401 "layout(triangles) in;\n"
402 "layout(triangle_strip, max_vertices=3) out;\n"
404 "out gl_PerVertex {\n"
405 " vec4 gl_Position;\n"
410 " gl_Position = gl_in[0].gl_Position;\n"
411 " outInstanceIndex = inInstanceIndex[0];\n"
414 << writeShadingRate <<
417 " gl_Position = gl_in[1].gl_Position;\n"
418 " outInstanceIndex = inInstanceIndex[1];\n"
421 << writeShadingRate <<
424 " gl_Position = gl_in[2].gl_Position;\n"
425 " outInstanceIndex = inInstanceIndex[2];\n"
428 << writeShadingRate <<
432 programCollection.glslSources.add("geom") << glu::GeometrySource(gss.str());
435 std::stringstream fss;
438 "#version 450 core\n"
439 "#extension GL_EXT_fragment_shading_rate : enable\n"
440 "#extension GL_ARB_shader_stencil_export : enable\n"
441 "#extension GL_ARB_fragment_shader_interlock : enable\n"
442 "layout(location = 0) out uvec4 col0;\n"
443 "layout(set = 0, binding = 0) buffer Block { uint counter; } buf;\n"
444 "layout(set = 0, binding = 3) uniform usampler2D tex;\n"
445 "layout(location = 0) flat in int instanceIndex;\n"
446 "layout(location = 1) flat in int readbackok;\n"
447 "layout(location = 2) " << (m_data.sampleShadingInput ? "sample " : "") << "in float zero;\n";
449 if (m_data.interlock)
450 fss << "layout(pixel_interlock_ordered) in;\n";
456 if (m_data.interlock)
457 fss << " beginInvocationInterlockARB();\n";
460 // X component gets shading rate enum
461 " col0.x = gl_ShadingRateEXT;\n"
463 // Z component gets packed primitiveID | atomic value
464 " col0.z = (instanceIndex << 24) | ((atomicAdd(buf.counter, 1) + 1) & 0x00FFFFFFu);\n"
465 " ivec2 fragCoordXY = ivec2(gl_FragCoord.xy);\n"
466 " ivec2 fragSize = ivec2(1<<((gl_ShadingRateEXT/4)&3), 1<<(gl_ShadingRateEXT&3));\n"
467 // W component gets error code
468 " col0.w = uint(zero)" << (m_data.sampleShadingInput ? " * gl_SampleID" : "") << ";\n"
469 " if (((fragCoordXY - fragSize / 2) % fragSize) != ivec2(0,0))\n"
470 " col0.w = " << ERROR_FRAGCOORD_CENTER << ";\n";
472 if (m_data.shaderWritesRate)
475 " if (readbackok != 1)\n"
476 " col0.w = " << ERROR_VTG_READBACK << ";\n";
479 // When sample shading, gl_FragCoord is more likely to give bad derivatives,
480 // e.g. due to a partially covered quad having some pixels center sample and
481 // some sample at a sample location.
482 if (!m_data.sampleShadingEnable && !m_data.sampleShadingInput)
484 fss << " if (dFdx(gl_FragCoord.xy) != ivec2(fragSize.x, 0) || dFdy(gl_FragCoord.xy) != ivec2(0, fragSize.y))\n"
485 " col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (int(dFdx(gl_FragCoord.xy)) << 14) | (int(dFdx(gl_FragCoord.xy)) << 8) | " << ERROR_FRAGCOORD_DERIV << ";\n";
487 fss << " uint implicitDerivX = texture(tex, vec2(gl_FragCoord.x / textureSize(tex, 0).x, 0)).x;\n"
488 " uint implicitDerivY = texture(tex, vec2(0, gl_FragCoord.y / textureSize(tex, 0).y)).x;\n"
489 " if (implicitDerivX != fragSize.x || implicitDerivY != fragSize.y)\n"
490 " col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (implicitDerivY << 14) | (implicitDerivX << 8) | " << ERROR_FRAGCOORD_IMPLICIT_DERIV << ";\n";
492 // Y component gets sample mask value
493 if (m_data.useSampleMaskIn)
494 fss << " col0.y = gl_SampleMaskIn[0];\n";
496 if (m_data.fragDepth)
497 fss << " gl_FragDepth = float(instanceIndex) / float(" << NUM_TRIANGLES << ");\n";
499 if (m_data.fragStencil)
500 fss << " gl_FragStencilRefARB = instanceIndex;\n";
502 if (m_data.interlock)
503 fss << " endInvocationInterlockARB();\n";
508 programCollection.glslSources.add("frag") << glu::FragmentSource(fss.str());
510 std::stringstream css;
512 std::string fsampType = m_data.samples > 1 ? "texture2DMSArray" : "texture2DArray";
513 std::string usampType = m_data.samples > 1 ? "utexture2DMSArray" : "utexture2DArray";
515 // Compute shader copies color/depth/stencil to linear layout in buffer memory
517 "#version 450 core\n"
518 "#extension GL_EXT_samplerless_texture_functions : enable\n"
519 "layout(set = 0, binding = 1) uniform " << usampType << " colorTex;\n"
520 "layout(set = 0, binding = 2, std430) buffer Block0 { uvec4 b[]; } colorbuf;\n"
521 "layout(set = 0, binding = 4, std430) buffer Block1 { float b[]; } depthbuf;\n"
522 "layout(set = 0, binding = 5, std430) buffer Block2 { uint b[]; } stencilbuf;\n"
523 "layout(set = 0, binding = 6) uniform " << fsampType << " depthTex;\n"
524 "layout(set = 0, binding = 7) uniform " << usampType << " stencilTex;\n"
525 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
528 " for (int i = 0; i < " << m_data.samples << "; ++i) {\n"
529 " uint idx = ((gl_GlobalInvocationID.z * " << m_data.framebufferDim.height << " + gl_GlobalInvocationID.y) * " << m_data.framebufferDim.width << " + gl_GlobalInvocationID.x) * " << m_data.samples << " + i;\n"
530 " colorbuf.b[idx] = texelFetch(colorTex, ivec3(gl_GlobalInvocationID.xyz), i);\n";
532 if (m_data.fragDepth)
533 css << " depthbuf.b[idx] = texelFetch(depthTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
535 if (m_data.fragStencil)
536 css << " stencilbuf.b[idx] = texelFetch(stencilTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
542 programCollection.glslSources.add("comp") << glu::ComputeSource(css.str());
545 TestInstance* FSRTestCase::createInstance (Context& context) const
547 return new FSRTestInstance(context, m_data);
550 deInt32 FSRTestInstance::ShadingRateExtentToEnum(VkExtent2D ext) const
552 ext.width = deCtz32(ext.width);
553 ext.height = deCtz32(ext.height);
555 return (ext.width << 2) | ext.height;
558 VkExtent2D FSRTestInstance::ShadingRateEnumToExtent(deInt32 rate) const
561 ret.width = 1 << ((rate/4) & 3);
562 ret.height = 1 << (rate & 3);
567 VkExtent2D FSRTestInstance::Combine(VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const
575 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
577 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR:
579 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR:
580 ret = { de::min(ext0.width, ext1.width), de::min(ext0.height, ext1.height) };
582 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR:
583 ret = { de::max(ext0.width, ext1.width), de::max(ext0.height, ext1.height) };
585 case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR:
586 ret = { ext0.width * ext1.width, ext0.height * ext1.height };
587 if (!m_shadingRateProperties.fragmentShadingRateStrictMultiplyCombiner)
589 if (ext0.width == 1 && ext1.width == 1)
591 if (ext0.height == 1 && ext1.height == 1)
598 deInt32 FSRTestInstance::Simulate(deInt32 rate0, deInt32 rate1, deInt32 rate2)
600 deInt32 &cachedRate = m_simulateCache[(rate2*m_simulateValueCount + rate1)*m_simulateValueCount + rate0];
601 if (cachedRate != ~0)
604 VkExtent2D extent0 = ShadingRateEnumToExtent(rate0);
605 VkExtent2D extent1 = ShadingRateEnumToExtent(rate1);
606 VkExtent2D extent2 = ShadingRateEnumToExtent(rate2);
608 deInt32 finalMask = 0;
609 // Simulate once for implementations that don't allow swapping rate xy,
610 // and once for those that do. Any of those results is allowed.
611 for (deUint32 allowSwap = 0; allowSwap <= 1; ++allowSwap)
613 // Combine rate 0 and 1, get a mask of possible clamped rates
614 VkExtent2D intermed = Combine(extent0, extent1, m_data.combinerOp[0]);
615 deInt32 intermedMask = ShadingRateExtentToClampedMask(intermed, allowSwap == 1);
617 // For each clamped rate, combine that with rate 2 and accumulate the possible clamped rates
618 for (int i = 0; i < 16; ++i)
620 if (intermedMask & (1<<i))
622 VkExtent2D final = Combine(ShadingRateEnumToExtent(i), extent2, m_data.combinerOp[1]);
623 finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
627 // unclamped intermediate value is also permitted
628 VkExtent2D final = Combine(intermed, extent2, m_data.combinerOp[1]);
629 finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
636 cachedRate = finalMask;
640 // If a rate is not valid (<=4x4), clamp it to something valid.
641 // This is only used for "inputs" to the system, not to mimic
642 // how the implementation internally clamps intermediate values.
643 VkExtent2D FSRTestInstance::SanitizeExtent(VkExtent2D ext) const
645 DE_ASSERT(ext.width > 0 && ext.height > 0);
647 ext.width = de::min(ext.width, 4u);
648 ext.height = de::min(ext.height, 4u);
653 // Map an extent to a mask of all modes smaller than or equal to it in either dimension
654 deInt32 FSRTestInstance::ShadingRateExtentToClampedMask(VkExtent2D ext, bool allowSwap) const
656 deUint32 desiredSize = ext.width * ext.height;
660 while (desiredSize > 0)
662 // First, find modes that maximize the area
663 for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
665 const VkPhysicalDeviceFragmentShadingRateKHR &supportedRate = m_supportedFragmentShadingRates[i];
666 if ((supportedRate.sampleCounts & m_data.samples) &&
667 supportedRate.fragmentSize.width * supportedRate.fragmentSize.height == desiredSize &&
668 ((supportedRate.fragmentSize.width <= ext.width && supportedRate.fragmentSize.height <= ext.height) ||
669 (supportedRate.fragmentSize.height <= ext.width && supportedRate.fragmentSize.width <= ext.height && allowSwap)))
671 mask |= 1 << ShadingRateExtentToEnum(supportedRate.fragmentSize);
676 // Amongst the modes that maximize the area, pick the ones that
677 // minimize the aspect ratio. Prefer ratio of 1, then 2, then 4.
678 // 1x1 = 0, 2x2 = 5, 4x4 = 10
679 static const deUint32 aspectMaskRatio1 = 0x421;
680 // 2x1 = 4, 1x2 = 1, 4x2 = 9, 2x4 = 6
681 static const deUint32 aspectMaskRatio2 = 0x252;
683 static const deUint32 aspectMaskRatio4 = 0x104;
685 if (mask & aspectMaskRatio1)
687 mask &= aspectMaskRatio1;
690 if (mask & aspectMaskRatio2)
692 mask &= aspectMaskRatio2;
695 if (mask & aspectMaskRatio4)
697 mask &= aspectMaskRatio4;
709 deInt32 FSRTestInstance::SanitizeRate(deInt32 rate) const
711 VkExtent2D extent = ShadingRateEnumToExtent(rate);
713 extent = SanitizeExtent(extent);
715 return ShadingRateExtentToEnum(extent);
718 // Map primID % 9 to primitive shading rate
719 deInt32 FSRTestInstance::PrimIDToPrimitiveShadingRate(deInt32 primID)
721 deInt32 &cachedRate = m_primIDToPrimitiveShadingRate[primID];
722 if (cachedRate != ~0)
726 extent.width = 1 << (primID % 3);
727 extent.height = 1 << ((primID/3) % 3);
729 cachedRate = ShadingRateExtentToEnum(extent);
733 // Map primID / 9 to pipeline shading rate
734 deInt32 FSRTestInstance::PrimIDToPipelineShadingRate(deInt32 primID)
736 deInt32 &cachedRate = m_primIDToPipelineShadingRate[primID];
737 if (cachedRate != ~0)
742 extent.width = 1 << (primID % 3);
743 extent.height = 1 << ((primID/3) % 3);
745 cachedRate = ShadingRateExtentToEnum(extent);
749 static de::MovePtr<BufferWithMemory> CreateCachedBuffer(const vk::DeviceInterface& vk,
750 const vk::VkDevice device,
751 vk::Allocator& allocator,
752 const vk::VkBufferCreateInfo& bufferCreateInfo)
756 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
757 vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible | MemoryRequirement::Cached));
759 catch (const tcu::NotSupportedError&)
761 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
762 vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible));
766 tcu::TestStatus FSRTestInstance::iterate (void)
768 const DeviceInterface& vk = m_context.getDeviceInterface();
769 const VkDevice device = m_context.getDevice();
770 tcu::TestLog& log = m_context.getTestContext().getLog();
771 Allocator& allocator = m_context.getDefaultAllocator();
772 VkFlags allShaderStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
773 VkFlags allPipelineStages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
774 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
775 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
776 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
777 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
778 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
779 VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV;
781 if (m_data.geometryShader)
783 allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
784 allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
788 deRandom_init(&rnd, m_data.seed);
790 qpTestResult res = QP_TEST_RESULT_PASS;
791 deUint32 numUnexpected1x1Samples = 0;
792 deUint32 numTotalSamples = 0;
796 ATTACHMENT_MODE_DEFAULT = 0,
797 ATTACHMENT_MODE_LAYOUT_OPTIMAL,
798 ATTACHMENT_MODE_IMAGELESS,
799 ATTACHMENT_MODE_2DARRAY,
800 ATTACHMENT_MODE_TILING_LINEAR,
802 ATTACHMENT_MODE_COUNT,
805 deUint32 numSRLayers = m_data.srLayered ? 2u : 1u;
807 VkExtent2D minFragmentShadingRateAttachmentTexelSize = {1, 1};
808 VkExtent2D maxFragmentShadingRateAttachmentTexelSize = {1, 1};
809 deUint32 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = 1;
810 if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
812 minFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().minFragmentShadingRateAttachmentTexelSize;
813 maxFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSize;
814 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
817 VkDeviceSize atomicBufferSize = sizeof(deUint32);
819 de::MovePtr<BufferWithMemory> atomicBuffer;
820 atomicBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
821 vk, device, allocator, makeBufferCreateInfo(atomicBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
823 deUint32 *abuf = (deUint32 *)atomicBuffer->getAllocation().getHostPtr();
825 // NUM_TRIANGLES triangles, 3 vertices, 2 components of float position
826 VkDeviceSize vertexBufferSize = NUM_TRIANGLES * 3 * 2 * sizeof(float);
828 de::MovePtr<BufferWithMemory> vertexBuffer;
829 vertexBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
830 vk, device, allocator, makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
832 float *vbuf = (float *)vertexBuffer->getAllocation().getHostPtr();
833 for (deInt32 i = 0; i < (deInt32)(vertexBufferSize / sizeof(float)); ++i)
835 vbuf[i] = deRandom_getFloat(&rnd)*2.0f - 1.0f;
837 flushAlloc(vk, device, vertexBuffer->getAllocation());
839 VkDeviceSize colorOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * 4 * sizeof(deUint32) * m_data.numColorLayers;
840 de::MovePtr<BufferWithMemory> colorOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(colorOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
842 VkDeviceSize depthOutputBufferSize = 0, stencilOutputBufferSize = 0;
843 de::MovePtr<BufferWithMemory> depthOutputBuffer, stencilOutputBuffer;
844 if (m_data.useDepthStencil)
846 depthOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(float) * m_data.numColorLayers;
847 depthOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(depthOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
849 stencilOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(deUint32) * m_data.numColorLayers;
850 stencilOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(stencilOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
853 deUint32 minSRTexelWidth = minFragmentShadingRateAttachmentTexelSize.width;
854 deUint32 minSRTexelHeight = minFragmentShadingRateAttachmentTexelSize.height;
855 deUint32 maxSRWidth = (m_data.framebufferDim.width + minSRTexelWidth - 1) / minSRTexelWidth;
856 deUint32 maxSRHeight = (m_data.framebufferDim.height + minSRTexelHeight - 1) / minSRTexelHeight;
858 // max size over all formats
859 VkDeviceSize srFillBufferSize = numSRLayers * maxSRWidth * maxSRHeight * 32/*4 component 64-bit*/;
860 de::MovePtr<BufferWithMemory> srFillBuffer;
861 deUint8 *fillPtr = DE_NULL;
862 if (m_data.useAttachment())
864 srFillBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(srFillBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
865 fillPtr = (deUint8 *)srFillBuffer->getAllocation().getHostPtr();
868 de::MovePtr<ImageWithMemory> cbImage;
869 Move<VkImageView> cbImageView;
871 const VkImageCreateInfo imageCreateInfo =
873 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
874 DE_NULL, // const void* pNext;
875 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
876 VK_IMAGE_TYPE_2D, // VkImageType imageType;
877 VK_FORMAT_R32G32B32A32_UINT, // VkFormat format;
879 m_data.framebufferDim.width, // deUint32 width;
880 m_data.framebufferDim.height, // deUint32 height;
881 1u // deUint32 depth;
882 }, // VkExtent3D extent;
883 1u, // deUint32 mipLevels;
884 m_data.numColorLayers, // deUint32 arrayLayers;
885 m_data.samples, // VkSampleCountFlagBits samples;
886 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
887 cbUsage, // VkImageUsageFlags usage;
888 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
889 0u, // deUint32 queueFamilyIndexCount;
890 DE_NULL, // const deUint32* pQueueFamilyIndices;
891 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
893 cbImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
894 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
896 VkImageViewCreateInfo imageViewCreateInfo =
898 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
899 DE_NULL, // const void* pNext;
900 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
901 **cbImage, // VkImage image;
902 VK_IMAGE_VIEW_TYPE_2D_ARRAY, // VkImageViewType viewType;
903 VK_FORMAT_R32G32B32A32_UINT, // VkFormat format;
905 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
906 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
907 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
908 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
909 }, // VkComponentMapping components;
911 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
912 0u, // deUint32 baseMipLevel;
913 1u, // deUint32 levelCount;
914 0u, // deUint32 baseArrayLayer;
915 m_data.numColorLayers // deUint32 layerCount;
916 } // VkImageSubresourceRange subresourceRange;
918 cbImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
921 de::MovePtr<ImageWithMemory> dsImage;
922 Move<VkImageView> dsImageView, dImageView, sImageView;
923 VkImageUsageFlags dsUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
924 VK_IMAGE_USAGE_SAMPLED_BIT |
925 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
926 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
927 if (m_data.useDepthStencil)
929 const VkImageCreateInfo imageCreateInfo =
931 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
932 DE_NULL, // const void* pNext;
933 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
934 VK_IMAGE_TYPE_2D, // VkImageType imageType;
935 VK_FORMAT_D32_SFLOAT_S8_UINT, // VkFormat format;
937 m_data.framebufferDim.width, // deUint32 width;
938 m_data.framebufferDim.height, // deUint32 height;
939 1u // deUint32 depth;
940 }, // VkExtent3D extent;
941 1u, // deUint32 mipLevels;
942 m_data.numColorLayers, // deUint32 arrayLayers;
943 m_data.samples, // VkSampleCountFlagBits samples;
944 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
945 dsUsage, // VkImageUsageFlags usage;
946 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
947 0u, // deUint32 queueFamilyIndexCount;
948 DE_NULL, // const deUint32* pQueueFamilyIndices;
949 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
951 dsImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
952 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
954 VkImageViewCreateInfo imageViewCreateInfo =
956 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
957 DE_NULL, // const void* pNext;
958 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
959 **dsImage, // VkImage image;
960 VK_IMAGE_VIEW_TYPE_2D_ARRAY, // VkImageViewType viewType;
961 VK_FORMAT_D32_SFLOAT_S8_UINT, // VkFormat format;
963 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
964 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
965 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
966 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
967 }, // VkComponentMapping components;
969 VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
970 0u, // deUint32 baseMipLevel;
971 1u, // deUint32 levelCount;
972 0u, // deUint32 baseArrayLayer;
973 m_data.numColorLayers // deUint32 layerCount;
974 } // VkImageSubresourceRange subresourceRange;
976 dsImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
977 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
978 dImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
979 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
980 sImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
983 // Image used to test implicit derivative calculations.
984 // Filled with a value of 1<<lod.
985 de::MovePtr<ImageWithMemory> derivImage;
986 Move<VkImageView> derivImageView;
987 VkImageUsageFlags derivUsage = VK_IMAGE_USAGE_SAMPLED_BIT |
988 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
989 deUint32 derivNumLevels;
991 deUint32 maxDim = de::max(m_context.getFragmentShadingRateProperties().maxFragmentSize.width, m_context.getFragmentShadingRateProperties().maxFragmentSize.height);
992 derivNumLevels = 1 + deCtz32(maxDim);
993 const VkImageCreateInfo imageCreateInfo =
995 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
996 DE_NULL, // const void* pNext;
997 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
998 VK_IMAGE_TYPE_2D, // VkImageType imageType;
999 VK_FORMAT_R32_UINT, // VkFormat format;
1001 m_context.getFragmentShadingRateProperties().maxFragmentSize.width, // deUint32 width;
1002 m_context.getFragmentShadingRateProperties().maxFragmentSize.height, // deUint32 height;
1003 1u // deUint32 depth;
1004 }, // VkExtent3D extent;
1005 derivNumLevels, // deUint32 mipLevels;
1006 1u, // deUint32 arrayLayers;
1007 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1008 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1009 derivUsage, // VkImageUsageFlags usage;
1010 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1011 0u, // deUint32 queueFamilyIndexCount;
1012 DE_NULL, // const deUint32* pQueueFamilyIndices;
1013 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1015 derivImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1016 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1018 VkImageViewCreateInfo imageViewCreateInfo =
1020 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1021 DE_NULL, // const void* pNext;
1022 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1023 **derivImage, // VkImage image;
1024 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
1025 VK_FORMAT_R32_UINT, // VkFormat format;
1027 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1028 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1029 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1030 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1031 }, // VkComponentMapping components;
1033 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1034 0u, // deUint32 baseMipLevel;
1035 derivNumLevels, // deUint32 levelCount;
1036 0u, // deUint32 baseArrayLayer;
1037 1u // deUint32 layerCount;
1038 } // VkImageSubresourceRange subresourceRange;
1040 derivImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1043 // sampler used with derivImage
1044 const struct VkSamplerCreateInfo samplerInfo =
1046 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // sType
1049 VK_FILTER_NEAREST, // magFilter
1050 VK_FILTER_NEAREST, // minFilter
1051 VK_SAMPLER_MIPMAP_MODE_NEAREST, // mipmapMode
1052 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeU
1053 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeV
1054 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeW
1056 VK_FALSE, // anisotropyEnable
1057 1.0f, // maxAnisotropy
1058 DE_FALSE, // compareEnable
1059 VK_COMPARE_OP_ALWAYS, // compareOp
1061 (float)derivNumLevels, // maxLod
1062 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, // borderColor
1063 VK_FALSE, // unnormalizedCoords
1066 Move<VkSampler> sampler = createSampler(vk, device, &samplerInfo);
1068 Move<vk::VkDescriptorSetLayout> descriptorSetLayout;
1069 VkDescriptorSetLayoutCreateFlags layoutCreateFlags = 0;
1071 const VkDescriptorSetLayoutBinding bindings[] =
1075 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1076 1u, // descriptorCount
1077 allShaderStages, // stageFlags
1078 DE_NULL, // pImmutableSamplers
1082 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1083 1u, // descriptorCount
1084 allShaderStages, // stageFlags
1085 DE_NULL, // pImmutableSamplers
1089 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1090 1u, // descriptorCount
1091 allShaderStages, // stageFlags
1092 DE_NULL, // pImmutableSamplers
1096 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // descriptorType
1097 1u, // descriptorCount
1098 allShaderStages, // stageFlags
1099 DE_NULL, // pImmutableSamplers
1103 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1104 1u, // descriptorCount
1105 allShaderStages, // stageFlags
1106 DE_NULL, // pImmutableSamplers
1110 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
1111 1u, // descriptorCount
1112 allShaderStages, // stageFlags
1113 DE_NULL, // pImmutableSamplers
1117 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1118 1u, // descriptorCount
1119 allShaderStages, // stageFlags
1120 DE_NULL, // pImmutableSamplers
1124 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1125 1u, // descriptorCount
1126 allShaderStages, // stageFlags
1127 DE_NULL, // pImmutableSamplers
1131 // Create a layout and allocate a descriptor set for it.
1132 const VkDescriptorSetLayoutCreateInfo setLayoutCreateInfo =
1134 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
1136 layoutCreateFlags, // flags
1137 sizeof(bindings)/sizeof(bindings[0]), // bindingCount
1138 &bindings[0] // pBindings
1141 descriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo);
1143 const VkPushConstantRange pushConstantRange =
1145 allShaderStages, // VkShaderStageFlags stageFlags;
1146 0u, // deUint32 offset;
1147 sizeof(deInt32) // deUint32 size;
1150 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1152 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
1154 (VkPipelineLayoutCreateFlags)0,
1155 1, // setLayoutCount
1156 &descriptorSetLayout.get(), // pSetLayouts
1157 1u, // pushConstantRangeCount
1158 &pushConstantRange, // pPushConstantRanges
1161 Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo, NULL);
1163 const Unique<VkShaderModule> cs (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
1165 const VkPipelineShaderStageCreateInfo csShaderCreateInfo =
1167 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1169 (VkPipelineShaderStageCreateFlags)0,
1170 VK_SHADER_STAGE_COMPUTE_BIT, // stage
1173 DE_NULL, // pSpecializationInfo
1176 const VkComputePipelineCreateInfo pipelineCreateInfo =
1178 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1181 csShaderCreateInfo, // cs
1182 *pipelineLayout, // layout
1183 (vk::VkPipeline)0, // basePipelineHandle
1184 0u, // basePipelineIndex
1186 Move<VkPipeline> computePipeline = createComputePipeline(vk, device, DE_NULL, &pipelineCreateInfo, NULL);
1188 for (deUint32 modeIdx = 0; modeIdx < ATTACHMENT_MODE_COUNT; ++modeIdx)
1190 // If we're not using an attachment, don't test all the different attachment modes
1191 if (modeIdx != ATTACHMENT_MODE_DEFAULT && !m_data.useAttachment())
1194 // Consider all uint formats possible
1195 static const VkFormat srFillFormats[] =
1198 VK_FORMAT_R8G8_UINT,
1199 VK_FORMAT_R8G8B8_UINT,
1200 VK_FORMAT_R8G8B8A8_UINT,
1202 VK_FORMAT_R16G16_UINT,
1203 VK_FORMAT_R16G16B16_UINT,
1204 VK_FORMAT_R16G16B16A16_UINT,
1206 VK_FORMAT_R32G32_UINT,
1207 VK_FORMAT_R32G32B32_UINT,
1208 VK_FORMAT_R32G32B32A32_UINT,
1210 VK_FORMAT_R64G64_UINT,
1211 VK_FORMAT_R64G64B64_UINT,
1212 VK_FORMAT_R64G64B64A64_UINT,
1214 // Only test all formats in the default mode
1215 deUint32 numFillFormats = modeIdx == ATTACHMENT_MODE_DEFAULT ? (deUint32)(sizeof(srFillFormats)/sizeof(srFillFormats[0])) : 1u;
1217 // Iterate over all supported tile sizes and formats
1218 for (deUint32 srTexelWidth = minFragmentShadingRateAttachmentTexelSize.width;
1219 srTexelWidth <= maxFragmentShadingRateAttachmentTexelSize.width;
1221 for (deUint32 srTexelHeight = minFragmentShadingRateAttachmentTexelSize.height;
1222 srTexelHeight <= maxFragmentShadingRateAttachmentTexelSize.height;
1224 for (deUint32 formatIdx = 0; formatIdx < numFillFormats; ++formatIdx)
1227 deUint32 aspectRatio = (srTexelHeight > srTexelWidth) ? (srTexelHeight / srTexelWidth) : (srTexelWidth / srTexelHeight);
1228 if (aspectRatio > maxFragmentShadingRateAttachmentTexelSizeAspectRatio)
1231 // Go through the loop only once when not using an attachment
1232 if (!m_data.useAttachment() &&
1233 (srTexelWidth != minFragmentShadingRateAttachmentTexelSize.width ||
1234 srTexelHeight != minFragmentShadingRateAttachmentTexelSize.height ||
1238 bool imagelessFB = modeIdx == ATTACHMENT_MODE_IMAGELESS;
1240 deUint32 srWidth = (m_data.framebufferDim.width + srTexelWidth - 1) / srTexelWidth;
1241 deUint32 srHeight = (m_data.framebufferDim.height + srTexelHeight - 1) / srTexelHeight;
1243 VkFormat srFormat = srFillFormats[formatIdx];
1244 deUint32 srFillBpp = tcu::getPixelSize(mapVkFormat(srFormat));
1246 VkImageLayout srLayout = modeIdx == ATTACHMENT_MODE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR : VK_IMAGE_LAYOUT_GENERAL;
1247 VkImageViewType srViewType = modeIdx == ATTACHMENT_MODE_2DARRAY ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
1248 VkImageTiling srTiling = (modeIdx == ATTACHMENT_MODE_TILING_LINEAR) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
1250 VkFormatProperties srFormatProperties;
1251 m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), srFormat, &srFormatProperties);
1252 VkFormatFeatureFlags srFormatFeatures = srTiling == VK_IMAGE_TILING_LINEAR ? srFormatProperties.linearTilingFeatures : srFormatProperties.optimalTilingFeatures;
1254 if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
1255 !(srFormatFeatures & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR))
1257 if (srFormat == VK_FORMAT_R8_UINT && srTiling == VK_IMAGE_TILING_OPTIMAL)
1259 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;
1260 res = QP_TEST_RESULT_FAIL;
1265 Move<vk::VkDescriptorPool> descriptorPool;
1266 Move<vk::VkDescriptorSet> descriptorSet;
1267 VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
1269 vk::DescriptorPoolBuilder poolBuilder;
1270 for (deInt32 i = 0; i < (deInt32)(sizeof(bindings)/sizeof(bindings[0])); ++i)
1271 poolBuilder.addType(bindings[i].descriptorType, bindings[i].descriptorCount);
1273 descriptorPool = poolBuilder.build(vk, device, poolCreateFlags, 1u);
1274 descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
1276 de::MovePtr<ImageWithMemory> srImage;
1277 Move<VkImageView> srImageView;
1278 VkImageUsageFlags srUsage = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR |
1279 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
1280 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1282 if (m_data.useAttachment())
1284 const VkImageCreateInfo imageCreateInfo =
1286 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1287 DE_NULL, // const void* pNext;
1288 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1289 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1290 srFormat, // VkFormat format;
1292 srWidth, // deUint32 width;
1293 srHeight, // deUint32 height;
1294 1u // deUint32 depth;
1295 }, // VkExtent3D extent;
1296 1u, // deUint32 mipLevels;
1297 numSRLayers, // deUint32 arrayLayers;
1298 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1299 srTiling, // VkImageTiling tiling;
1300 srUsage, // VkImageUsageFlags usage;
1301 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1302 0u, // deUint32 queueFamilyIndexCount;
1303 DE_NULL, // const deUint32* pQueueFamilyIndices;
1304 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
1306 srImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1307 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1309 VkImageViewCreateInfo imageViewCreateInfo =
1311 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
1312 DE_NULL, // const void* pNext;
1313 (VkImageViewCreateFlags)0u, // VkImageViewCreateFlags flags;
1314 **srImage, // VkImage image;
1315 srViewType, // VkImageViewType viewType;
1316 srFormat, // VkFormat format;
1318 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r;
1319 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g;
1320 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b;
1321 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a;
1322 }, // VkComponentMapping components;
1324 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1325 0u, // deUint32 baseMipLevel;
1326 1u, // deUint32 levelCount;
1327 0u, // deUint32 baseArrayLayer;
1328 numSRLayers // deUint32 layerCount;
1329 } // VkImageSubresourceRange subresourceRange;
1331 srImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1334 VkDescriptorImageInfo imageInfo;
1335 VkDescriptorBufferInfo bufferInfo;
1337 VkWriteDescriptorSet w =
1339 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
1341 *descriptorSet, // dstSet
1342 (deUint32)0, // dstBinding
1343 0, // dstArrayElement
1344 1u, // descriptorCount
1345 bindings[0].descriptorType, // descriptorType
1346 &imageInfo, // pImageInfo
1347 &bufferInfo, // pBufferInfo
1348 DE_NULL, // pTexelBufferView
1352 flushAlloc(vk, device, atomicBuffer->getAllocation());
1354 bufferInfo = makeDescriptorBufferInfo(**atomicBuffer, 0, atomicBufferSize);
1356 w.descriptorType = bindings[0].descriptorType;
1357 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1359 imageInfo = makeDescriptorImageInfo(DE_NULL, *cbImageView, VK_IMAGE_LAYOUT_GENERAL);
1361 w.descriptorType = bindings[1].descriptorType;
1362 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1364 bufferInfo = makeDescriptorBufferInfo(**colorOutputBuffer, 0, colorOutputBufferSize);
1366 w.descriptorType = bindings[2].descriptorType;
1367 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1369 imageInfo = makeDescriptorImageInfo(*sampler, *derivImageView, VK_IMAGE_LAYOUT_GENERAL);
1371 w.descriptorType = bindings[3].descriptorType;
1372 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1374 if (m_data.useDepthStencil)
1376 bufferInfo = makeDescriptorBufferInfo(**depthOutputBuffer, 0, depthOutputBufferSize);
1378 w.descriptorType = bindings[4].descriptorType;
1379 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1381 bufferInfo = makeDescriptorBufferInfo(**stencilOutputBuffer, 0, stencilOutputBufferSize);
1383 w.descriptorType = bindings[5].descriptorType;
1384 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1386 imageInfo = makeDescriptorImageInfo(DE_NULL, *dImageView, VK_IMAGE_LAYOUT_GENERAL);
1388 w.descriptorType = bindings[6].descriptorType;
1389 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1391 imageInfo = makeDescriptorImageInfo(DE_NULL, *sImageView, VK_IMAGE_LAYOUT_GENERAL);
1393 w.descriptorType = bindings[7].descriptorType;
1394 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1397 Move<VkRenderPass> renderPass;
1398 Move<VkFramebuffer> framebuffer;
1400 std::vector<VkImageView> attachments;
1401 attachments.push_back(*cbImageView);
1402 deUint32 dsAttachmentIdx = 0, srAttachmentIdx = 0;
1403 if (m_data.useAttachment())
1405 srAttachmentIdx = (deUint32)attachments.size();
1406 attachments.push_back(*srImageView);
1408 if (m_data.useDepthStencil)
1410 dsAttachmentIdx = (deUint32)attachments.size();
1411 attachments.push_back(*dsImageView);
1414 const vk::VkAttachmentReference2 colorAttachmentReference =
1416 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1419 vk::VK_IMAGE_LAYOUT_GENERAL, // layout
1423 const vk::VkAttachmentReference2 fragmentShadingRateAttachment =
1425 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1427 srAttachmentIdx, // attachment
1432 const vk::VkAttachmentReference2 depthAttachmentReference =
1434 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // sType
1436 dsAttachmentIdx, // attachment
1437 vk::VK_IMAGE_LAYOUT_GENERAL, // layout
1441 const bool noAttachmentPtr = (m_data.attachmentUsage == AttachmentUsage::NO_ATTACHMENT_PTR);
1442 const VkFragmentShadingRateAttachmentInfoKHR shadingRateAttachmentInfo =
1444 VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, // VkStructureType sType;
1445 DE_NULL, // const void* pNext;
1446 (noAttachmentPtr ? nullptr : &fragmentShadingRateAttachment), // const VkAttachmentReference2* pFragmentShadingRateAttachment;
1447 { srTexelWidth, srTexelHeight }, // VkExtent2D shadingRateAttachmentTexelSize;
1450 const bool useAttachmentInfo = (m_data.attachmentUsage != AttachmentUsage::NO_ATTACHMENT);
1451 const VkSubpassDescription2 subpassDesc =
1453 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, // sType
1454 (useAttachmentInfo ? &shadingRateAttachmentInfo : nullptr), // pNext;
1455 (vk::VkSubpassDescriptionFlags)0, // flags
1456 vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
1457 m_data.multiView ? 0x3 : 0u, // viewMask
1459 DE_NULL, // pInputAttachments
1461 &colorAttachmentReference, // pColorAttachments
1462 DE_NULL, // pResolveAttachments
1463 m_data.useDepthStencil ? &depthAttachmentReference : DE_NULL, // depthStencilAttachment
1464 0u, // preserveCount
1465 DE_NULL, // pPreserveAttachments
1468 std::vector<VkAttachmentDescription2> attachmentDescriptions;
1469 attachmentDescriptions.push_back(
1471 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1472 DE_NULL, // const void* pNext;
1473 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1474 VK_FORMAT_R32G32B32A32_UINT, // VkFormat format;
1475 m_data.samples, // VkSampleCountFlagBits samples;
1476 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1477 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1478 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1479 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1480 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
1481 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
1484 if (m_data.useAttachment())
1485 attachmentDescriptions.push_back(
1487 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1488 DE_NULL, // const void* pNext;
1489 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1490 srFormat, // VkFormat format;
1491 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1492 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1493 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1494 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
1495 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
1496 srLayout, // VkImageLayout initialLayout;
1497 srLayout // VkImageLayout finalLayout;
1501 if (m_data.useDepthStencil)
1502 attachmentDescriptions.push_back(
1504 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
1505 DE_NULL, // const void* pNext;
1506 (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
1507 VK_FORMAT_D32_SFLOAT_S8_UINT, // VkFormat format;
1508 m_data.samples, // VkSampleCountFlagBits samples;
1509 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
1510 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
1511 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp stencilLoadOp;
1512 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp stencilStoreOp;
1513 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
1514 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
1518 const VkRenderPassCreateInfo2 renderPassParams =
1520 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, // sType
1522 (vk::VkRenderPassCreateFlags)0,
1523 (deUint32)attachmentDescriptions.size(), // attachmentCount
1524 &attachmentDescriptions[0], // pAttachments
1526 &subpassDesc, // pSubpasses
1527 0u, // dependencyCount
1528 DE_NULL, // pDependencies
1529 0u, // correlatedViewMaskCount
1530 DE_NULL, // pCorrelatedViewMasks
1533 renderPass = createRenderPass2(vk, device, &renderPassParams);
1535 std::vector<VkFramebufferAttachmentImageInfo> framebufferAttachmentImageInfo;
1536 framebufferAttachmentImageInfo.push_back(
1538 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1539 DE_NULL, // const void* pNext;
1540 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1541 cbUsage, // VkImageUsageFlags usage;
1542 m_data.framebufferDim.width, // deUint32 width;
1543 m_data.framebufferDim.height, // deUint32 height;
1544 m_data.numColorLayers, // deUint32 layerCount;
1545 0u, // deUint32 viewFormatCount;
1546 DE_NULL // const VkFormat* pViewFormats;
1549 if (m_data.useAttachment())
1550 framebufferAttachmentImageInfo.push_back(
1552 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1553 DE_NULL, // const void* pNext;
1554 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1555 srUsage, // VkImageUsageFlags usage;
1556 srWidth, // deUint32 width;
1557 srHeight, // deUint32 height;
1558 numSRLayers, // deUint32 layerCount;
1559 0u, // deUint32 viewFormatCount;
1560 DE_NULL // const VkFormat* pViewFormats;
1564 if (m_data.useDepthStencil)
1565 framebufferAttachmentImageInfo.push_back(
1567 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, // VkStructureType sType;
1568 DE_NULL, // const void* pNext;
1569 (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
1570 dsUsage, // VkImageUsageFlags usage;
1571 m_data.framebufferDim.width, // deUint32 width;
1572 m_data.framebufferDim.height, // deUint32 height;
1573 m_data.numColorLayers, // deUint32 layerCount;
1574 0u, // deUint32 viewFormatCount;
1575 DE_NULL // const VkFormat* pViewFormats;
1579 const VkFramebufferAttachmentsCreateInfo framebufferAttachmentsCreateInfo =
1581 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, // VkStructureType sType;
1582 DE_NULL, // const void* pNext;
1583 (deUint32)framebufferAttachmentImageInfo.size(), // deUint32 attachmentImageInfoCount;
1584 &framebufferAttachmentImageInfo[0] // const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos;
1587 const vk::VkFramebufferCreateInfo framebufferParams =
1589 vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
1590 imagelessFB ? &framebufferAttachmentsCreateInfo : DE_NULL, // pNext
1591 (vk::VkFramebufferCreateFlags)(imagelessFB ? VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT : 0),
1592 *renderPass, // renderPass
1593 (deUint32)attachments.size(), // attachmentCount
1594 imagelessFB ? DE_NULL : &attachments[0], // pAttachments
1595 m_data.framebufferDim.width, // width
1596 m_data.framebufferDim.height, // height
1597 m_data.multiView ? 1 : m_data.numColorLayers, // layers
1600 framebuffer = createFramebuffer(vk, device, &framebufferParams);
1602 const VkVertexInputBindingDescription vertexBinding =
1604 0u, // deUint32 binding;
1605 sizeof(float) * 2, // deUint32 stride;
1606 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
1608 const VkVertexInputAttributeDescription vertexInputAttributeDescription =
1610 0u, // deUint32 location;
1611 0u, // deUint32 binding;
1612 VK_FORMAT_R32G32_SFLOAT, // VkFormat format;
1613 0u // deUint32 offset;
1616 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
1618 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1619 DE_NULL, // const void* pNext;
1620 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
1621 1u, // deUint32 vertexBindingDescriptionCount;
1622 &vertexBinding, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1623 1u, // deUint32 vertexAttributeDescriptionCount;
1624 &vertexInputAttributeDescription // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1627 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo =
1629 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1630 DE_NULL, // const void* pNext;
1631 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
1632 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
1633 VK_FALSE // VkBool32 primitiveRestartEnable;
1636 const VkPipelineRasterizationConservativeStateCreateInfoEXT consRastState =
1638 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, // VkStructureType sType;
1639 DE_NULL, // const void* pNext;
1640 (VkPipelineRasterizationConservativeStateCreateFlagsEXT)0, // VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
1641 m_data.conservativeMode, // VkConservativeRasterizationModeEXT conservativeRasterizationMode;
1642 0.0f, // float extraPrimitiveOverestimationSize;
1645 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
1647 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1648 m_data.conservativeEnable ? &consRastState : DE_NULL, // const void* pNext;
1649 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
1650 VK_FALSE, // VkBool32 depthClampEnable;
1651 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
1652 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
1653 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
1654 VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace;
1655 VK_FALSE, // VkBool32 depthBiasEnable;
1656 0.0f, // float depthBiasConstantFactor;
1657 0.0f, // float depthBiasClamp;
1658 0.0f, // float depthBiasSlopeFactor;
1659 1.0f // float lineWidth;
1662 // Kill some bits from each AA mode
1663 const VkSampleMask sampleMask = m_data.sampleMaskTest ? 0x9 : 0x7D56;
1664 const VkSampleMask* pSampleMask = m_data.useApiSampleMask ? &sampleMask : DE_NULL;
1666 // All samples at pixel center. We'll validate that pixels are fully covered or uncovered.
1667 std::vector<VkSampleLocationEXT> sampleLocations(m_data.samples, { 0.5f, 0.5f });
1668 const VkSampleLocationsInfoEXT sampleLocationsInfo =
1670 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, // VkStructureType sType;
1671 DE_NULL, // const void* pNext;
1672 (VkSampleCountFlagBits)m_data.samples, // VkSampleCountFlagBits sampleLocationsPerPixel;
1673 { 1, 1 }, // VkExtent2D sampleLocationGridSize;
1674 (deUint32)m_data.samples, // uint32_t sampleLocationsCount;
1675 &sampleLocations[0], // const VkSampleLocationEXT* pSampleLocations;
1678 const VkPipelineSampleLocationsStateCreateInfoEXT pipelineSampleLocationsCreateInfo =
1680 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, // VkStructureType sType;
1681 DE_NULL, // const void* pNext;
1682 VK_TRUE, // VkBool32 sampleLocationsEnable;
1683 sampleLocationsInfo, // VkSampleLocationsInfoEXT sampleLocationsInfo;
1686 const VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo =
1688 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType
1689 m_data.sampleLocations ? &pipelineSampleLocationsCreateInfo : DE_NULL, // const void* pNext
1690 0u, // VkPipelineMultisampleStateCreateFlags flags
1691 (VkSampleCountFlagBits)m_data.samples, // VkSampleCountFlagBits rasterizationSamples
1692 (VkBool32)m_data.sampleShadingEnable, // VkBool32 sampleShadingEnable
1693 1.0f, // float minSampleShading
1694 pSampleMask, // const VkSampleMask* pSampleMask
1695 VK_FALSE, // VkBool32 alphaToCoverageEnable
1696 VK_FALSE // VkBool32 alphaToOneEnable
1699 std::vector<VkViewport> viewports;
1700 std::vector<VkRect2D> scissors;
1701 if (m_data.multiViewport)
1703 // Split the viewport into left and right halves
1704 int x0 = 0, x1 = m_data.framebufferDim.width/2, x2 = m_data.framebufferDim.width;
1706 viewports.push_back(makeViewport((float)x0, 0, (float)(x1-x0), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1707 scissors.push_back(makeRect2D(x0, 0, x1-x0, m_data.framebufferDim.height));
1709 viewports.push_back(makeViewport((float)x1, 0, (float)(x2-x1), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1710 scissors.push_back(makeRect2D(x1, 0, x2-x1, m_data.framebufferDim.height));
1714 viewports.push_back(makeViewport(m_data.framebufferDim.width, m_data.framebufferDim.height));
1715 scissors.push_back(makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height));
1718 const VkPipelineViewportStateCreateInfo viewportStateCreateInfo =
1720 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType
1721 DE_NULL, // const void* pNext
1722 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags
1723 (deUint32)viewports.size(), // deUint32 viewportCount
1724 &viewports[0], // const VkViewport* pViewports
1725 (deUint32)scissors.size(), // deUint32 scissorCount
1726 &scissors[0] // const VkRect2D* pScissors
1729 Move<VkShaderModule> fragShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0);
1730 Move<VkShaderModule> vertShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0);
1731 Move<VkShaderModule> geomShader;
1732 if (m_data.geometryShader)
1733 geomShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("geom"), 0);
1735 deUint32 numStages = m_data.geometryShader ? 3 : 2u;
1737 const VkPipelineShaderStageCreateInfo shaderCreateInfo[3] =
1740 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1742 (VkPipelineShaderStageCreateFlags)0,
1743 VK_SHADER_STAGE_VERTEX_BIT, // stage
1744 *vertShader, // shader
1746 DE_NULL, // pSpecializationInfo
1749 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1751 (VkPipelineShaderStageCreateFlags)0,
1752 VK_SHADER_STAGE_FRAGMENT_BIT, // stage
1753 *fragShader, // shader
1755 DE_NULL, // pSpecializationInfo
1758 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1760 (VkPipelineShaderStageCreateFlags)0,
1761 VK_SHADER_STAGE_GEOMETRY_BIT, // stage
1762 *geomShader, // shader
1764 DE_NULL, // pSpecializationInfo
1768 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
1770 VK_FALSE, // VkBool32 blendEnable;
1771 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor;
1772 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
1773 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
1774 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor;
1775 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
1776 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
1777 0xf // VkColorComponentFlags colorWriteMask;
1780 const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
1782 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
1783 DE_NULL, // const void* pNext;
1784 0u, // VkPipelineColorBlendStateCreateFlags flags;
1785 VK_FALSE, // VkBool32 logicOpEnable;
1786 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1787 1u, // deUint32 attachmentCount;
1788 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
1789 { 1.0f, 1.0f, 1.0f, 1.0f } // float blendConstants[4];
1792 const deUint32 fragSizeWH = m_data.sampleMaskTest ? 2 : 0;
1793 VkPipelineFragmentShadingRateStateCreateInfoKHR shadingRateStateCreateInfo =
1795 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, // VkStructureType sType;
1796 DE_NULL, // const void* pNext;
1797 { fragSizeWH, fragSizeWH }, // VkExtent2D fragmentSize;
1798 { m_data.combinerOp[0], m_data.combinerOp[1] }, // VkFragmentShadingRateCombinerOpKHR combinerOps[2];
1801 VkDynamicState dynamicState = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR;
1802 const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
1804 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
1805 DE_NULL, // const void* pNext;
1806 (VkPipelineDynamicStateCreateFlags)0, // VkPipelineDynamicStateCreateFlags flags;
1807 m_data.useDynamicState ? 1u : 0u, // uint32_t dynamicStateCount;
1808 &dynamicState, // const VkDynamicState* pDynamicStates;
1811 // Enable depth/stencil writes, always passing
1812 VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
1814 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
1815 DE_NULL, // const void* pNext;
1816 0u, // VkPipelineDepthStencilStateCreateFlags flags;
1817 VK_TRUE, // VkBool32 depthTestEnable;
1818 VK_TRUE, // VkBool32 depthWriteEnable;
1819 VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp;
1820 VK_FALSE, // VkBool32 depthBoundsTestEnable;
1821 VK_TRUE, // VkBool32 stencilTestEnable;
1822 // VkStencilOpState front;
1824 VK_STENCIL_OP_REPLACE, // VkStencilOp failOp;
1825 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
1826 VK_STENCIL_OP_REPLACE, // VkStencilOp depthFailOp;
1827 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1828 0u, // deUint32 compareMask;
1829 0xFFu, // deUint32 writeMask;
1830 0xFFu, // deUint32 reference;
1832 // VkStencilOpState back;
1834 VK_STENCIL_OP_REPLACE, // VkStencilOp failOp;
1835 VK_STENCIL_OP_REPLACE, // VkStencilOp passOp;
1836 VK_STENCIL_OP_REPLACE, // VkStencilOp depthFailOp;
1837 VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
1838 0u, // deUint32 compareMask;
1839 0xFFu, // deUint32 writeMask;
1840 0xFFu, // deUint32 reference;
1842 0.0f, // float minDepthBounds;
1843 0.0f, // float maxDepthBounds;
1846 const VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo =
1848 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1849 &shadingRateStateCreateInfo, // const void* pNext;
1850 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
1851 numStages, // deUint32 stageCount;
1852 &shaderCreateInfo[0], // const VkPipelineShaderStageCreateInfo* pStages;
1853 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1854 &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1855 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1856 &viewportStateCreateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState;
1857 &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
1858 &multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1859 &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1860 &colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1861 &dynamicStateCreateInfo, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1862 pipelineLayout.get(), // VkPipelineLayout layout;
1863 renderPass.get(), // VkRenderPass renderPass;
1864 0u, // deUint32 subpass;
1865 DE_NULL, // VkPipeline basePipelineHandle;
1866 0 // int basePipelineIndex;
1870 VkImageMemoryBarrier imageBarrier =
1872 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
1873 DE_NULL, // const void* pNext
1874 0u, // VkAccessFlags srcAccessMask
1875 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
1876 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout
1877 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout newLayout
1878 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
1879 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
1880 **cbImage, // VkImage image
1882 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
1883 0u, // uint32_t baseMipLevel
1884 VK_REMAINING_MIP_LEVELS, // uint32_t mipLevels,
1885 0u, // uint32_t baseArray
1886 VK_REMAINING_ARRAY_LAYERS, // uint32_t arraySize
1890 const VkQueue queue = m_context.getUniversalQueue();
1891 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, m_context.getUniversalQueueFamilyIndex());
1892 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1894 beginCommandBuffer(vk, *cmdBuffer, 0u);
1896 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1897 (VkDependencyFlags)0,
1898 0, (const VkMemoryBarrier*)DE_NULL,
1899 0, (const VkBufferMemoryBarrier*)DE_NULL,
1902 imageBarrier.image = **derivImage;
1903 imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
1905 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1906 (VkDependencyFlags)0,
1907 0, (const VkMemoryBarrier*)DE_NULL,
1908 0, (const VkBufferMemoryBarrier*)DE_NULL,
1911 // Clear level to 1<<level
1912 for (deUint32 i = 0; i < derivNumLevels; ++i)
1914 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, i, 1u, 0u, 1u);
1915 VkClearValue clearColor = makeClearValueColorU32(1<<i,0,0,0);
1916 vk.cmdClearColorImage(*cmdBuffer, **derivImage, VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);
1919 // Clear color buffer to transparent black
1921 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
1922 VkClearValue clearColor = makeClearValueColorU32(0,0,0,0);
1924 vk.cmdClearColorImage(*cmdBuffer, **cbImage, VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);
1927 // Clear depth and stencil
1928 if (m_data.useDepthStencil)
1930 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
1931 VkClearValue clearColor = makeClearValueDepthStencil(0.0, 0);
1932 VkImageMemoryBarrier dsBarrier = imageBarrier;
1933 dsBarrier.image = **dsImage;
1934 dsBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
1935 dsBarrier.subresourceRange = range;
1936 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1937 0u, // dependencyFlags
1941 vk.cmdClearDepthStencilImage(*cmdBuffer, **dsImage, VK_IMAGE_LAYOUT_GENERAL, &clearColor.depthStencil, 1, &range);
1944 // Initialize shading rate image with varying values
1945 if (m_data.useAttachment())
1947 imageBarrier.image = **srImage;
1948 imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
1950 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1951 (VkDependencyFlags)0,
1952 0, (const VkMemoryBarrier*)DE_NULL,
1953 0, (const VkBufferMemoryBarrier*)DE_NULL,
1956 deMemset(fillPtr, 0, (size_t)srFillBufferSize);
1957 for (deUint32 layer = 0; layer < numSRLayers; ++layer)
1959 for (deUint32 x = 0; x < srWidth; ++x)
1961 for (deUint32 y = 0; y < srHeight; ++y)
1963 deUint32 idx = (layer*srHeight + y)*srWidth + x;
1964 deUint8 val = (deUint8)SanitizeRate(idx & 0xF);
1965 // actual shading rate is always in the LSBs of the first byte of a texel
1966 fillPtr[srFillBpp*idx] = val;
1970 flushAlloc(vk, device, srFillBuffer->getAllocation());
1972 const VkBufferImageCopy copyRegion =
1974 0u, // VkDeviceSize bufferOffset;
1975 0u, // deUint32 bufferRowLength;
1976 0u, // deUint32 bufferImageHeight;
1978 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspect;
1979 0u, // deUint32 mipLevel;
1980 0u, // deUint32 baseArrayLayer;
1981 numSRLayers, // deUint32 layerCount;
1982 }, // VkImageSubresourceLayers imageSubresource;
1983 { 0, 0, 0 }, // VkOffset3D imageOffset;
1984 { srWidth, srHeight, 1 }, // VkExtent3D imageExtent;
1987 vk.cmdCopyBufferToImage(*cmdBuffer, **srFillBuffer, **srImage, VK_IMAGE_LAYOUT_GENERAL, 1, ©Region);
1989 imageBarrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
1990 imageBarrier.newLayout = srLayout;
1992 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1993 (VkDependencyFlags)0,
1994 0, (const VkMemoryBarrier*)DE_NULL,
1995 0, (const VkBufferMemoryBarrier*)DE_NULL,
1999 VkMemoryBarrier memBarrier =
2001 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
2003 0u, // srcAccessMask
2004 0u, // dstAccessMask
2007 memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
2008 memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
2009 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, allPipelineStages,
2010 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2012 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0, 1, &descriptorSet.get(), 0, DE_NULL);
2014 vector<Move<VkPipeline>> pipelines;
2016 // If using dynamic state, create a single graphics pipeline and bind it
2017 if (m_data.useDynamicState)
2019 pipelines.push_back(createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo));
2020 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelines[0]);
2023 const VkRenderPassAttachmentBeginInfo renderPassAttachmentBeginInfo =
2025 VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, // VkStructureType sType;
2026 DE_NULL, // const void* pNext;
2027 (deUint32)attachments.size(), // deUint32 attachmentCount;
2028 &attachments[0] // const VkImageView* pAttachments;
2031 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer,
2032 makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height),
2033 0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE, imagelessFB ? &renderPassAttachmentBeginInfo : DE_NULL);
2035 for (deInt32 i = 0; i < NUM_TRIANGLES; ++i)
2037 // Bind vertex attributes pointing to the next triangle
2038 VkDeviceSize vertexBufferOffset = i*3*2*sizeof(float);
2039 VkBuffer vb = **vertexBuffer;
2040 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vb, &vertexBufferOffset);
2042 // Put primitive shading rate in a push constant
2043 deInt32 shadingRatePC = PrimIDToPrimitiveShadingRate(i);
2044 vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, allShaderStages, 0, sizeof(shadingRatePC), &shadingRatePC);
2046 if (m_data.useDynamicState)
2048 VkExtent2D fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2049 vk.cmdSetFragmentShadingRateKHR(*cmdBuffer, &fragmentSize, m_data.combinerOp);
2053 // Create a new pipeline with the desired pipeline shading rate
2054 shadingRateStateCreateInfo.fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2055 pipelines.push_back(createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo));
2056 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelines.back());
2059 // Draw one triangle, with "primitive ID" in gl_InstanceIndex
2060 vk.cmdDraw(*cmdBuffer, 3u, 1, 0u, i);
2063 endRenderPass(vk, *cmdBuffer);
2065 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;
2066 memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
2067 vk.cmdPipelineBarrier(*cmdBuffer, allPipelineStages, allPipelineStages,
2068 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2070 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1, &*descriptorSet, 0u, DE_NULL);
2071 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline);
2073 // Copy color/depth/stencil buffers to buffer memory
2074 vk.cmdDispatch(*cmdBuffer, m_data.framebufferDim.width, m_data.framebufferDim.height, m_data.numColorLayers);
2076 memBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
2077 memBarrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
2078 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
2079 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2081 endCommandBuffer(vk, *cmdBuffer);
2083 submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
2085 deUint32 *colorptr = (deUint32 *)colorOutputBuffer->getAllocation().getHostPtr();
2086 invalidateAlloc(vk, device, colorOutputBuffer->getAllocation());
2088 invalidateAlloc(vk, device, atomicBuffer->getAllocation());
2090 float *depthptr = DE_NULL;
2091 deUint32 *stencilptr = DE_NULL;
2093 if (m_data.useDepthStencil)
2095 depthptr = (float *)depthOutputBuffer->getAllocation().getHostPtr();
2096 invalidateAlloc(vk, device, depthOutputBuffer->getAllocation());
2098 stencilptr = (deUint32 *)stencilOutputBuffer->getAllocation().getHostPtr();
2099 invalidateAlloc(vk, device, stencilOutputBuffer->getAllocation());
2102 // Loop over all samples and validate the output
2103 for (deUint32 layer = 0; layer < m_data.numColorLayers && res == QP_TEST_RESULT_PASS; ++layer)
2105 for (deUint32 y = 0; y < m_data.framebufferDim.height && res == QP_TEST_RESULT_PASS; ++y)
2107 for (deUint32 x = 0; x < m_data.framebufferDim.width && res == QP_TEST_RESULT_PASS; ++x)
2109 for (deInt32 s = 0; s < m_data.samples && res == QP_TEST_RESULT_PASS; ++s)
2111 deUint32 *sample = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2113 // If testing the rasterizer sample mask, if this sample is not set in the
2114 // mask then it shouldn't have written anything.
2115 if (m_data.useApiSampleMask && !(sampleMask & (1 << s)) && sample[2] != 0)
2117 log << tcu::TestLog::Message << std::hex << "sample written despite pSampleMask (" << x << "," << y << ",sample " << s << ")" << tcu::TestLog::EndMessage;
2118 res = QP_TEST_RESULT_FAIL;
2122 // The same isn't covered by any primitives, skip it
2126 // skip samples that have the same value as sample zero - it would be redundant to check them.
2129 deUint32 *sample0 = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0)];
2130 bool same = deMemCmp(sample, sample0, 16) == 0;
2132 if (m_data.fragDepth)
2134 float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2135 float *dsample0 = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2136 same = same && (*dsample == *dsample0);
2139 if (m_data.fragStencil)
2141 deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2142 deUint32 *ssample0 = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2143 same = same && (*ssample == *ssample0);
2150 // Fragment shader writes error codes to .w component.
2151 // All nonzero values are unconditionally failures
2154 if (sample[3] == ERROR_FRAGCOORD_CENTER)
2155 log << tcu::TestLog::Message << std::hex << "fragcoord test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2156 else if (sample[3] == ERROR_VTG_READBACK)
2157 log << tcu::TestLog::Message << std::hex << "vs/gs output readback test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2158 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_DERIV)
2159 log << tcu::TestLog::Message << std::hex << "fragcoord derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2160 "(0x" << ((sample[3] >> 8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2161 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2162 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_IMPLICIT_DERIV)
2163 log << tcu::TestLog::Message << std::hex << "implicit derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2164 "(0x" << ((sample[3] >> 8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2165 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2167 log << tcu::TestLog::Message << std::hex << "w coord unknown test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2168 res = QP_TEST_RESULT_FAIL;
2172 // x component of sample
2173 deUint32 rate = sample[0];
2175 deUint32 pixelsX = 1 << ((rate/4)&3);
2176 deUint32 pixelsY = 1 << (rate&3);
2179 deUint32 fragMinX = x & ~(pixelsX-1);
2180 deUint32 fragMinY = y & ~(pixelsY-1);
2181 deUint32 fragMaxX = fragMinX + pixelsX;
2182 deUint32 fragMaxY = fragMinY + pixelsY;
2184 // Clamp to FB dimension for odd sizes
2185 if (fragMaxX > m_data.framebufferDim.width)
2186 fragMaxX = m_data.framebufferDim.width;
2187 if (fragMaxY > m_data.framebufferDim.height)
2188 fragMaxY = m_data.framebufferDim.height;
2190 // z component of sample
2191 deUint32 primID = sample[2] >> 24;
2192 deUint32 atomVal = sample[2] & 0xFFFFFF;
2194 // Compute pipeline and primitive rate from primitive ID, and attachment
2195 // rate from the x/y coordinate
2196 deInt32 pipelineRate = PrimIDToPipelineShadingRate(primID);
2197 deInt32 primitiveRate = m_data.shaderWritesRate ? PrimIDToPrimitiveShadingRate(primID) : 0;
2199 deInt32 attachmentLayer = m_data.srLayered ? layer : 0;
2200 deInt32 attachmentRate = m_data.useAttachment() ? fillPtr[srFillBpp*((attachmentLayer * srHeight + (y / srTexelHeight)) * srWidth + (x / srTexelWidth))] : 0;
2202 // Get mask of allowed shading rates
2203 deInt32 expectedMasks = Simulate(pipelineRate, primitiveRate, attachmentRate);
2205 if (!(expectedMasks & (1 << rate)))
2207 log << tcu::TestLog::Message << std::hex << "unexpected shading rate. failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ") "
2208 "result rate 0x" << rate << " mask of expected rates 0x" << expectedMasks <<
2209 " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate << tcu::TestLog::EndMessage;
2210 res = QP_TEST_RESULT_FAIL;
2213 // Check that not all fragments are downgraded to 1x1
2214 if (rate == 0 && expectedMasks != 1)
2215 numUnexpected1x1Samples++;
2218 // Check that gl_FragDepth = primID / NUM_TRIANGLES
2219 if (m_data.fragDepth)
2221 float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2222 float expected = (float)primID / NUM_TRIANGLES;
2223 if (fabs(*dsample - expected) > 0.01)
2225 log << tcu::TestLog::Message << std::hex << "depth write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *dsample << " expected " << expected << tcu::TestLog::EndMessage;
2226 res = QP_TEST_RESULT_FAIL;
2231 // Check that stencil value = primID
2232 if (m_data.fragStencil)
2234 deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2235 if (*ssample != primID)
2237 log << tcu::TestLog::Message << std::hex << "stencil write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *ssample << " expected " << primID << tcu::TestLog::EndMessage;
2238 res = QP_TEST_RESULT_FAIL;
2243 // Check that primitives are in the right viewport/scissor
2244 if (m_data.multiViewport)
2246 VkRect2D *scissor = &scissors[primID & 1];
2247 if ((int)x < scissor->offset.x || (int)x >= (int)(scissor->offset.x + scissor->extent.width) ||
2248 (int)y < scissor->offset.y || (int)y >= (int)(scissor->offset.y + scissor->extent.height))
2250 log << tcu::TestLog::Message << std::hex << "primitive found outside of expected viewport (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << tcu::TestLog::EndMessage;
2251 res = QP_TEST_RESULT_FAIL;
2256 // Check that primitives are in the right layer
2257 if (m_data.colorLayered)
2259 if (layer != ((primID & 2)>>1))
2261 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;
2262 res = QP_TEST_RESULT_FAIL;
2267 // Check that multiview broadcasts the same primitive to both layers
2268 if (m_data.multiView)
2270 deUint32 otherLayer = layer^1;
2271 deUint32 *othersample = &colorptr[4*(((otherLayer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2272 deUint32 otherPrimID = othersample[2] >> 24;
2273 if (primID != otherPrimID)
2275 log << tcu::TestLog::Message << std::hex << "multiview primitive mismatch (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << " otherPrimID=" << otherPrimID << tcu::TestLog::EndMessage;
2276 res = QP_TEST_RESULT_FAIL;
2281 // Loop over all samples in the same fragment
2282 for (deUint32 fx = fragMinX; fx < fragMaxX; ++fx)
2284 for (deUint32 fy = fragMinY; fy < fragMaxY; ++fy)
2286 for (deInt32 fs = 0; fs < m_data.samples; ++fs)
2288 deUint32 *fsample = &colorptr[4*(((layer * m_data.framebufferDim.height + fy) * m_data.framebufferDim.width + fx)*m_data.samples + fs)];
2289 deUint32 frate = fsample[0];
2290 deUint32 fprimID = fsample[2] >> 24;
2291 deUint32 fatomVal = fsample[2] & 0xFFFFFF;
2293 // If we write out the sample mask value, check that the samples in the
2294 // mask must not be uncovered, and that samples not in the mask must not
2295 // be covered by this primitive
2296 if (m_data.useSampleMaskIn)
2298 int p = pixelsX * pixelsY - ((fx - fragMinX) + pixelsX * (fy - fragMinY)) - 1;
2299 int sampleIdx = fs + m_data.samples * p;
2301 if ((sample[1] & (1 << sampleIdx)) && fsample[2] == 0)
2303 log << tcu::TestLog::Message << std::hex << "sample set in sampleMask but not written (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2304 res = QP_TEST_RESULT_FAIL;
2307 if (!(sample[1] & (1 << sampleIdx)) && fsample[2] != 0 && fprimID == primID)
2309 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;
2310 res = QP_TEST_RESULT_FAIL;
2315 // If conservative raster is enabled, or custom sample locations all at the center, check that
2316 // samples in the same pixel must be covered.
2317 if (m_data.conservativeEnable ||
2318 (m_data.sampleLocations && m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations))
2320 // If it's in the same pixel, expect it to be fully covered.
2321 if (fx == x && fy == y && fsample[2] == 0)
2323 log << tcu::TestLog::Message << std::hex << "pixel not fully covered (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2324 res = QP_TEST_RESULT_FAIL;
2329 if (fsample[2] == 0)
2332 // If the primitive matches this sample, then it must have the same rate and
2334 if (fprimID == primID)
2336 if (rate != frate || (atomVal != fatomVal && !(m_data.sampleShadingEnable || m_data.sampleShadingInput)))
2338 log << tcu::TestLog::Message << std::hex << "failed pixel (0x" << x << ",0x" << y << ",sample " << s << ")=0x" << ((primID<<24)|atomVal) <<
2339 " compared to (0x" << fx << ",0x" << fy << ",sample " << fs << ")=0x" << ((fprimID<<24)|fatomVal) <<
2340 " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate <<
2341 tcu::TestLog::EndMessage;
2342 res = QP_TEST_RESULT_FAIL;
2352 if (res == QP_TEST_RESULT_FAIL)
2356 // All samples were coerced to 1x1, unexpected
2357 if (res == QP_TEST_RESULT_PASS &&
2358 numTotalSamples != 0 &&
2359 numUnexpected1x1Samples == numTotalSamples &&
2360 numTotalSamples > 16)
2362 log << tcu::TestLog::Message << std::hex << "Quality warning - all fragments used 1x1" << tcu::TestLog::EndMessage;
2363 res = QP_TEST_RESULT_QUALITY_WARNING;
2366 return tcu::TestStatus(res, qpGetTestResultName(res));
2371 void createBasicTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* parentGroup)
2377 const char* description;
2384 const char* description;
2389 AttachmentUsage usage;
2391 const char* description;
2392 } TestGroupUsageCase;
2394 TestGroupCase groupCases[] =
2396 { 0, "basic", "basic tests" },
2397 { 1, "apisamplemask", "use pSampleMask" },
2398 { 2, "samplemaskin", "use gl_SampleMaskIn" },
2399 { 3, "conservativeunder", "conservative underestimation" },
2400 { 4, "conservativeover", "conservative overestimation" },
2401 { 5, "fragdepth", "depth shader output" },
2402 { 6, "fragstencil", "stencil shader output" },
2403 { 7, "multiviewport", "multiple viewports and gl_ViewportIndex" },
2404 { 8, "colorlayered", "multiple layer color, single layer shading rate" },
2405 { 9, "srlayered", "multiple layer color, multiple layers shading rate" },
2406 { 10, "multiview", "multiview" },
2407 { 11, "multiviewsrlayered", "multiview and multilayer shading rate" },
2408 { 12, "interlock", "fragment shader interlock" },
2409 { 13, "samplelocations", "custom sample locations" },
2410 { 14, "sampleshadingenable", "enable sample shading in createinfo" },
2411 { 15, "sampleshadinginput", "enable sample shading by using gl_SampleID" },
2414 TestGroupCase dynCases[] =
2416 { 1, "dynamic", "uses dynamic shading rate state" },
2417 { 0, "static", "uses static shading rate state" },
2420 TestGroupUsageCase attCases[] =
2422 { AttachmentUsage::NO_ATTACHMENT, "noattachment", "no shading rate attachment" },
2423 { AttachmentUsage::WITH_ATTACHMENT, "attachment", "has shading rate attachment" },
2424 { AttachmentUsage::NO_ATTACHMENT_PTR, "noattachmentptr", "no shading rate attachment pointer" },
2427 TestGroupCase shdCases[] =
2429 { 0, "noshaderrate", "shader doesn't write rate" },
2430 { 1, "shaderrate", "shader writes rate" },
2433 TestGroupCase combCases[] =
2435 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, "keep", "keep" },
2436 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR, "replace", "replace" },
2437 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, "min", "min" },
2438 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, "max", "max" },
2439 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR, "mul", "mul" },
2442 TestGroupCase2D extentCases[] =
2444 { {1, 1}, "1x1", "1x1" },
2445 { {4, 4}, "4x4", "4x4" },
2446 { {33, 35}, "33x35", "33x35" },
2447 { {151, 431}, "151x431", "151x431" },
2448 { {256, 256}, "256x256", "256x256" },
2451 TestGroupCase sampCases[] =
2453 { VK_SAMPLE_COUNT_1_BIT, "samples1", "1 raster sample" },
2454 { VK_SAMPLE_COUNT_2_BIT, "samples2", "2 raster samples" },
2455 { VK_SAMPLE_COUNT_4_BIT, "samples4", "4 raster samples" },
2456 { VK_SAMPLE_COUNT_8_BIT, "samples8", "8 raster samples" },
2457 { VK_SAMPLE_COUNT_16_BIT, "samples16", "16 raster samples" },
2460 TestGroupCase geomCases[] =
2462 { 0, "vs", "vertex shader only" },
2463 { 1, "gs", "vertex and geometry shader" },
2468 for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(groupCases); groupNdx++)
2470 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, groupCases[groupNdx].name, groupCases[groupNdx].description));
2471 for (int dynNdx = 0; dynNdx < DE_LENGTH_OF_ARRAY(dynCases); dynNdx++)
2473 de::MovePtr<tcu::TestCaseGroup> dynGroup(new tcu::TestCaseGroup(testCtx, dynCases[dynNdx].name, dynCases[dynNdx].description));
2474 for (int attNdx = 0; attNdx < DE_LENGTH_OF_ARRAY(attCases); attNdx++)
2476 de::MovePtr<tcu::TestCaseGroup> attGroup(new tcu::TestCaseGroup(testCtx, attCases[attNdx].name, attCases[attNdx].description));
2477 for (int shdNdx = 0; shdNdx < DE_LENGTH_OF_ARRAY(shdCases); shdNdx++)
2479 de::MovePtr<tcu::TestCaseGroup> shdGroup(new tcu::TestCaseGroup(testCtx, shdCases[shdNdx].name, shdCases[shdNdx].description));
2480 for (int cmb0Ndx = 0; cmb0Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb0Ndx++)
2482 de::MovePtr<tcu::TestCaseGroup> cmb0Group(new tcu::TestCaseGroup(testCtx, combCases[cmb0Ndx].name, combCases[cmb0Ndx].description));
2483 for (int cmb1Ndx = 0; cmb1Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb1Ndx++)
2485 de::MovePtr<tcu::TestCaseGroup> cmb1Group(new tcu::TestCaseGroup(testCtx, combCases[cmb1Ndx].name, combCases[cmb1Ndx].description));
2486 for (int extNdx = 0; extNdx < DE_LENGTH_OF_ARRAY(extentCases); extNdx++)
2488 de::MovePtr<tcu::TestCaseGroup> extGroup(new tcu::TestCaseGroup(testCtx, extentCases[extNdx].name, extentCases[extNdx].description));
2489 for (int sampNdx = 0; sampNdx < DE_LENGTH_OF_ARRAY(sampCases); sampNdx++)
2491 de::MovePtr<tcu::TestCaseGroup> sampGroup(new tcu::TestCaseGroup(testCtx, sampCases[sampNdx].name, sampCases[sampNdx].description));
2492 for (int geomNdx = 0; geomNdx < DE_LENGTH_OF_ARRAY(geomCases); geomNdx++)
2494 bool useApiSampleMask = groupNdx == 1;
2495 bool useSampleMaskIn = groupNdx == 2;
2496 bool consRast = groupNdx == 3 || groupNdx == 4;
2497 bool fragDepth = groupNdx == 5;
2498 bool fragStencil = groupNdx == 6;
2499 bool multiViewport = groupNdx == 7;
2500 bool colorLayered = groupNdx == 8 || groupNdx == 9;
2501 bool srLayered = groupNdx == 9 || groupNdx == 11;
2502 bool multiView = groupNdx == 10 || groupNdx == 11;
2503 bool interlock = groupNdx == 12;
2504 bool sampleLocations = groupNdx == 13;
2505 bool sampleShadingEnable = groupNdx == 14;
2506 bool sampleShadingInput = groupNdx == 15;
2507 VkConservativeRasterizationModeEXT conservativeMode = (groupNdx == 3) ? VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT : VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT;
2508 deUint32 numColorLayers = (colorLayered || multiView) ? 2u : 1u;
2510 // Don't bother with geometry shader if we're not testing shader writes
2511 if (geomCases[geomNdx].count && !shdCases[shdNdx].count)
2514 // reduce number of tests
2515 if ((groupNdx != 0) &&
2516 (!dynCases[dynNdx].count ||
2517 !(combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
2518 !(combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
2521 // Don't bother with geometry shader if we're testing conservative raster, sample mask, depth/stencil
2522 if (geomCases[geomNdx].count && (useApiSampleMask || useSampleMaskIn || consRast || fragDepth || fragStencil))
2525 // Don't bother with geometry shader if we're testing non-dynamic state
2526 if (geomCases[geomNdx].count && !dynCases[dynNdx].count)
2529 // Only test multiViewport/layered with shaderWritesRate
2530 if ((multiViewport || colorLayered) && !shdCases[shdNdx].count)
2533 // Can't test layered shading rate attachment without an attachment
2534 if (srLayered && attCases[attNdx].usage != AttachmentUsage::WITH_ATTACHMENT)
2539 seed++, // deInt32 seed;
2540 extentCases[extNdx].count, // VkExtent2D framebufferDim;
2541 (VkSampleCountFlagBits)sampCases[sampNdx].count, // VkSampleCountFlagBits samples;
2543 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb0Ndx].count,
2544 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb1Ndx].count
2545 }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
2546 attCases[attNdx].usage, // AttachmentUsage attachmentUsage;
2547 (bool)shdCases[shdNdx].count, // bool shaderWritesRate;
2548 (bool)geomCases[geomNdx].count, // bool geometryShader;
2549 (bool)dynCases[dynNdx].count, // bool useDynamicState;
2550 useApiSampleMask, // bool useApiSampleMask;
2551 useSampleMaskIn, // bool useSampleMaskIn;
2552 consRast, // bool conservativeEnable;
2553 conservativeMode, // VkConservativeRasterizationModeEXT conservativeMode;
2554 fragDepth || fragStencil, // bool useDepthStencil;
2555 fragDepth, // bool fragDepth;
2556 fragStencil, // bool fragStencil;
2557 multiViewport, // bool multiViewport;
2558 colorLayered, // bool colorLayered;
2559 srLayered, // bool srLayered;
2560 numColorLayers, // deUint32 numColorLayers;
2561 multiView, // bool multiView;
2562 interlock, // bool interlock;
2563 sampleLocations, // bool sampleLocations;
2564 sampleShadingEnable, // bool sampleShadingEnable;
2565 sampleShadingInput, // bool sampleShadingInput;
2566 false, // bool sampleMaskTest;
2569 sampGroup->addChild(new FSRTestCase(testCtx, geomCases[geomNdx].name, geomCases[geomNdx].description, c));
2571 extGroup->addChild(sampGroup.release());
2573 cmb1Group->addChild(extGroup.release());
2575 cmb0Group->addChild(cmb1Group.release());
2577 shdGroup->addChild(cmb0Group.release());
2579 attGroup->addChild(shdGroup.release());
2581 dynGroup->addChild(attGroup.release());
2583 group->addChild(dynGroup.release());
2585 parentGroup->addChild(group.release());
2588 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "misc_tests", "Single tests that don't need to be part of above test matrix"));
2589 group->addChild(new FSRTestCase(testCtx, "sample_mask_test", "", {
2590 123, // deInt32 seed;
2591 {32, 33}, // VkExtent2D framebufferDim;
2592 VK_SAMPLE_COUNT_4_BIT, // VkSampleCountFlagBits samples;
2594 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
2595 VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
2596 }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
2597 AttachmentUsage::NO_ATTACHMENT, // AttachmentUsage attachmentUsage;
2598 true, // bool shaderWritesRate;
2599 false, // bool geometryShader;
2600 false, // bool useDynamicState;
2601 true, // bool useApiSampleMask;
2602 false, // bool useSampleMaskIn;
2603 false, // bool conservativeEnable;
2604 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, // VkConservativeRasterizationModeEXT conservativeMode;
2605 false, // bool useDepthStencil;
2606 false, // bool fragDepth;
2607 false, // bool fragStencil;
2608 false, // bool multiViewport;
2609 false, // bool colorLayered;
2610 false, // bool srLayered;
2611 1u, // deUint32 numColorLayers;
2612 false, // bool multiView;
2613 false, // bool interlock;
2614 false, // bool sampleLocations;
2615 false, // bool sampleShadingEnable;
2616 false, // bool sampleShadingInput;
2617 true, // bool sampleMaskTest;
2620 parentGroup->addChild(group.release());
2623 } // FragmentShadingRage