external/vulkancts/modules/vulkan/fragment_shading_rate/vktFragmentShadingRateBasic.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2017-2019 The Khronos Group Inc.
   6  * Copyright (c) 2018-2020 NVIDIA Corporation
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *        http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief 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  *//*--------------------------------------------------------------------*/
  34
  35 #include "vktFragmentShadingRateBasic.hpp"
  36
  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"
  45 #include "vkStrUtil.hpp"
  46
  47 #include "vktTestGroupUtil.hpp"
  48 #include "vktTestCase.hpp"
  49
  50 #include "deDefs.h"
  51 #include "deMath.h"
  52 #include "deRandom.h"
  53 #include "deSharedPtr.hpp"
  54 #include "deString.h"
  55
  56 #include "tcuTestCase.hpp"
  57 #include "tcuTestLog.hpp"
  58
  59 #include <set>
  60 #include <string>
  61 #include <sstream>
  62 #include <vector>
  63 #include <algorithm>
  64 #include <iterator>
  65
  66 namespace vkt
  67 {
  68 namespace FragmentShadingRate
  69 {
  70 namespace
  71 {
  72 using namespace vk;
  73 using namespace std;
  74
  75 #define NUM_TRIANGLES (9*9)
  76
  77 enum class AttachmentUsage
  78 {
  79         NO_ATTACHMENT = 0,
  80         NO_ATTACHMENT_PTR,
  81         WITH_ATTACHMENT,
  82         WITH_ATTACHMENT_WITHOUT_IMAGEVIEW, // No imageview at VkRenderingFragmentShadingRateAttachmentInfoKHR.
  83 };
  84
  85 struct CaseDef
  86 {
  87         SharedGroupParams groupParams;
  88         deInt32 seed;
  89         VkExtent2D framebufferDim;
  90         VkSampleCountFlagBits samples;
  91         VkFragmentShadingRateCombinerOpKHR combinerOp[2];
  92         AttachmentUsage attachmentUsage;
  93         bool shaderWritesRate;
  94         bool geometryShader;
  95         bool meshShader;
  96         bool useDynamicState;
  97         bool useApiSampleMask;
  98         bool useSampleMaskIn;
  99         bool conservativeEnable;
 100         VkConservativeRasterizationModeEXT conservativeMode;
 101         bool useDepthStencil; // == fragDepth || fragStencil
 102         bool fragDepth;
 103         bool fragStencil;
 104         bool multiViewport;
 105         bool colorLayered;
 106         bool srLayered; // colorLayered must also be true
 107         deUint32 numColorLayers;
 108         bool multiView;
 109         bool correlationMask;
 110         bool interlock;
 111         bool sampleLocations;
 112         bool sampleShadingEnable;
 113         bool sampleShadingInput;
 114         bool sampleMaskTest;
 115         bool earlyAndLateTest;
 116         bool garbageAttachment;
 117
 118         bool useAttachment () const
 119         {
 120                 return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT);
 121         }
 122
 123         bool useAttachmentWithoutImageView () const
 124         {
 125                 return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW);
 126         }
 127 };
 128
 129 class FSRTestInstance : public TestInstance
 130 {
 131 public:
 132                                                 FSRTestInstance                         (Context& context, const CaseDef& data);
 133                                                 ~FSRTestInstance                        (void);
 134         tcu::TestStatus         iterate                                         (void);
 135
 136 private:
 137         // Test parameters
 138         CaseDef                         m_data;
 139
 140         // Cache simulated combiner operations, to avoid recomputing per-sample
 141         deInt32                         m_simulateValueCount;
 142         vector<deInt32>         m_simulateCache;
 143         // Cache mapping of primitive ID to pipeline/primitive shading rate
 144         vector<deInt32>         m_primIDToPrimitiveShadingRate;
 145         vector<deInt32>         m_primIDToPipelineShadingRate;
 146         deUint32                        m_supportedFragmentShadingRateCount;
 147         vector<VkPhysicalDeviceFragmentShadingRateKHR>  m_supportedFragmentShadingRates;
 148         VkPhysicalDeviceFragmentShadingRatePropertiesKHR        m_shadingRateProperties;
 149
 150 protected:
 151
 152         void                            preRenderCommands                               (VkCommandBuffer                                                                        cmdBuffer,
 153                                                                                                                  ImageWithMemory*                                                                       cbImage,
 154                                                                                                                  ImageWithMemory*                                                                       dsImage,
 155                                                                                                                  ImageWithMemory*                                                                       derivImage,
 156                                                                                                                  deUint32                                                                                       derivNumLevels,
 157                                                                                                                  ImageWithMemory*                                                                       srImage,
 158                                                                                                                  VkImageLayout                                                                          srLayout,
 159                                                                                                                  BufferWithMemory*                                                                      srFillBuffer,
 160                                                                                                                  deUint32                                                                                       numSRLayers,
 161                                                                                                                  deUint32                                                                                       srWidth,
 162                                                                                                                  deUint32                                                                                       srHeight,
 163                                                                                                                  deUint32                                                                                       srFillBpp,
 164                                                                                                                  const VkClearValue&                                                            clearColor,
 165                                                                                                                  const VkClearValue&                                                            clearDepthStencil);
 166         void                            beginLegacyRender                               (VkCommandBuffer                                                                        cmdBuffer,
 167                                                                                                                  VkRenderPass                                                                           renderPass,
 168                                                                                                                  VkFramebuffer                                                                          framebuffer,
 169                                                                                                                  VkImageView                                                                            srImageView,
 170                                                                                                                  VkImageView                                                                            cbImageView,
 171                                                                                                                  VkImageView                                                                            dsImageView,
 172                                                                                                                  bool                                                                                           imagelessFB) const;
 173         void                            drawCommands                                    (VkCommandBuffer                                                                        cmdBuffer,
 174                                                                                                                  std::vector<GraphicsPipelineWrapper>&                          pipelines,
 175                                                                                                                  const std::vector<VkViewport>&                                         viewports,
 176                                                                                                                  const std::vector<VkRect2D>&                                           scissors,
 177                                                                                                                  const VkPipelineLayout                                                         pipelineLayout,
 178                                                                                                                  const VkRenderPass                                                                     renderPass,
 179                                                                                                                  const VkPipelineVertexInputStateCreateInfo*            vertexInputState,
 180                                                                                                                  const VkPipelineDynamicStateCreateInfo*                        dynamicState,
 181                                                                                                                  const VkPipelineRasterizationStateCreateInfo*          rasterizationState,
 182                                                                                                                  const VkPipelineDepthStencilStateCreateInfo*           depthStencilState,
 183                                                                                                                  const VkPipelineMultisampleStateCreateInfo*            multisampleState,
 184                                                                                                                  VkPipelineFragmentShadingRateStateCreateInfoKHR*       shadingRateState,
 185                                                                                                                  PipelineRenderingCreateInfoWrapper                                     dynamicRenderingState,
 186                                                                                                                  const VkShaderModule                                                           vertShader,
 187                                                                                                                  const VkShaderModule                                                           geomShader,
 188                                                                                                                  const VkShaderModule                                                           meshShader,
 189                                                                                                                  const VkShaderModule                                                           fragShader,
 190                                                                                                                  const std::vector<VkDescriptorSet>&                            descriptorSet,
 191                                                                                                                  VkBuffer                                                                                       vertexBuffer,
 192                                                                                                                  const uint32_t                                                                         pushConstantSize);
 193 #ifndef CTS_USES_VULKANSC
 194         void                            beginSecondaryCmdBuffer                 (VkCommandBuffer                                                                        cmdBuffer,
 195                                                                                                                  VkFormat                                                                                       cbFormat,
 196                                                                                                                  VkFormat                                                                                       dsFormat,
 197                                                                                                                  VkRenderingFlagsKHR                                                            renderingFlags = 0u) const;
 198         void                            beginDynamicRender                              (VkCommandBuffer                                                                        cmdBuffer,
 199                                                                                                                  VkImageView                                                                            srImageView,
 200                                                                                                                  VkImageLayout                                                                          srImageLayout,
 201                                                                                                                  const VkExtent2D&                                                                      srTexelSize,
 202                                                                                                                  VkImageView                                                                            cbImageView,
 203                                                                                                                  VkImageView                                                                            dsImageView,
 204                                                                                                                  const VkClearValue&                                                            clearColor,
 205                                                                                                                  const VkClearValue&                                                            clearDepthStencil,
 206                                                                                                                  VkRenderingFlagsKHR                                                            renderingFlags = 0u) const;
 207 #endif // CTS_USES_VULKANSC
 208
 209         deInt32                         PrimIDToPrimitiveShadingRate    (deInt32 primID);
 210         deInt32                         PrimIDToPipelineShadingRate             (deInt32 primID);
 211         VkExtent2D                      SanitizeExtent                                  (VkExtent2D ext) const;
 212         deInt32                         SanitizeRate                                    (deInt32 rate) const;
 213         deInt32                         ShadingRateExtentToClampedMask  (VkExtent2D ext, bool allowSwap) const;
 214         deInt32                         ShadingRateExtentToEnum                 (VkExtent2D ext) const;
 215         VkExtent2D                      ShadingRateEnumToExtent                 (deInt32 rate) const;
 216         deInt32                         Simulate                                                (deInt32 rate0, deInt32 rate1, deInt32 rate2);
 217         VkExtent2D                      Combine                                                 (VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const;
 218         bool                            Force1x1                                                () const;
 219 };
 220
 221 FSRTestInstance::FSRTestInstance (Context& context, const CaseDef& data)
 222         : vkt::TestInstance             (context)
 223         , m_data                                (data)
 224         , m_simulateValueCount  (((4 * 4) | 4) + 1)
 225         , m_simulateCache               (m_simulateValueCount*m_simulateValueCount*m_simulateValueCount, ~0)
 226         , m_primIDToPrimitiveShadingRate(NUM_TRIANGLES, ~0)
 227         , m_primIDToPipelineShadingRate(NUM_TRIANGLES, ~0)
 228 {
 229         m_supportedFragmentShadingRateCount = 0;
 230         m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, DE_NULL);
 231
 232         if (m_supportedFragmentShadingRateCount < 3)
 233                 TCU_THROW(TestError, "*pFragmentShadingRateCount too small");
 234
 235         m_supportedFragmentShadingRates.resize(m_supportedFragmentShadingRateCount);
 236         for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
 237         {
 238                 m_supportedFragmentShadingRates[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
 239                 m_supportedFragmentShadingRates[i].pNext = nullptr;
 240         }
 241         m_context.getInstanceInterface().getPhysicalDeviceFragmentShadingRatesKHR(m_context.getPhysicalDevice(), &m_supportedFragmentShadingRateCount, &m_supportedFragmentShadingRates[0]);
 242
 243         m_shadingRateProperties = m_context.getFragmentShadingRateProperties();
 244 }
 245
 246 FSRTestInstance::~FSRTestInstance (void)
 247 {
 248 }
 249
 250 class FSRTestCase : public TestCase
 251 {
 252         public:
 253                                                                 FSRTestCase             (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data);
 254                                                                 ~FSRTestCase    (void);
 255         virtual void                            initPrograms    (SourceCollections& programCollection) const;
 256         virtual TestInstance*           createInstance  (Context& context) const;
 257         virtual void                            checkSupport    (Context& context) const;
 258
 259 private:
 260         CaseDef                                         m_data;
 261 };
 262
 263 FSRTestCase::FSRTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data)
 264         : vkt::TestCase (context, name, desc)
 265         , m_data                (data)
 266 {
 267 }
 268
 269 FSRTestCase::~FSRTestCase       (void)
 270 {
 271 }
 272
 273 bool FSRTestInstance::Force1x1() const
 274 {
 275         if (m_data.useApiSampleMask && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
 276                 return true;
 277
 278         if (m_data.useSampleMaskIn && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderSampleMask)
 279                 return true;
 280
 281         if (m_data.conservativeEnable && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithConservativeRasterization)
 282                 return true;
 283
 284         if (m_data.useDepthStencil && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithShaderDepthStencilWrites)
 285                 return true;
 286
 287         if (m_data.interlock && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithFragmentShaderInterlock)
 288                 return true;
 289
 290         if (m_data.sampleLocations && !m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations)
 291                 return true;
 292
 293         if (m_data.sampleShadingEnable || m_data.sampleShadingInput)
 294                 return true;
 295
 296         return false;
 297 }
 298
 299 static VkImageUsageFlags cbUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
 300                                                                    VK_IMAGE_USAGE_SAMPLED_BIT |
 301                                                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT |
 302                                                                    VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
 303
 304 static VkImageUsageFlags dsUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
 305                                                                    VK_IMAGE_USAGE_SAMPLED_BIT |
 306                                                                    VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 307                                                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 308
 309
 310 void FSRTestCase::checkSupport(Context& context) const
 311 {
 312         context.requireDeviceFunctionality("VK_KHR_fragment_shading_rate");
 313
 314         if (m_data.groupParams->useDynamicRendering)
 315                 context.requireDeviceFunctionality("VK_KHR_dynamic_rendering");
 316
 317         if (!context.getFragmentShadingRateFeatures().pipelineFragmentShadingRate)
 318                 TCU_THROW(NotSupportedError, "pipelineFragmentShadingRate not supported");
 319
 320         if (m_data.shaderWritesRate &&
 321                 !context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate)
 322                 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
 323
 324         if (!context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate &&
 325                 m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
 326                 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRate not supported");
 327
 328         if (!context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
 329                 m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
 330                 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
 331
 332         const auto&             vki                     = context.getInstanceInterface();
 333         const auto              physDev         = context.getPhysicalDevice();
 334
 335         VkImageFormatProperties imageProperties;
 336         VkResult                                result                  = vki.getPhysicalDeviceImageFormatProperties(physDev, VK_FORMAT_R32G32B32A32_UINT, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, cbUsage, 0, &imageProperties);
 337
 338         if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
 339                 TCU_THROW(NotSupportedError, "VK_FORMAT_R32G32B32A32_UINT not supported");
 340
 341         if (m_data.geometryShader)
 342                 context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
 343
 344         if (!(imageProperties.sampleCounts & m_data.samples))
 345                 TCU_THROW(NotSupportedError, "color buffer sample count not supported");
 346
 347         if (m_data.numColorLayers > imageProperties.maxArrayLayers)
 348                 TCU_THROW(NotSupportedError, "color buffer layers not supported");
 349
 350         if (m_data.useAttachment() && !context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
 351                 TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
 352
 353         if (!context.getFragmentShadingRateProperties().fragmentShadingRateNonTrivialCombinerOps &&
 354                 ((m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[0] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
 355                  (m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR && m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
 356                 TCU_THROW(NotSupportedError, "fragmentShadingRateNonTrivialCombinerOps not supported");
 357
 358         if (m_data.conservativeEnable)
 359         {
 360                 context.requireDeviceFunctionality("VK_EXT_conservative_rasterization");
 361                 if (m_data.conservativeMode == VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT &&
 362                         !context.getConservativeRasterizationPropertiesEXT().primitiveUnderestimation)
 363                         TCU_THROW(NotSupportedError, "primitiveUnderestimation not supported");
 364         }
 365
 366         if (m_data.fragStencil)
 367                 context.requireDeviceFunctionality("VK_EXT_shader_stencil_export");
 368
 369         if (m_data.multiViewport &&
 370                 !context.getFragmentShadingRateProperties().primitiveFragmentShadingRateWithMultipleViewports)
 371                 TCU_THROW(NotSupportedError, "primitiveFragmentShadingRateWithMultipleViewports not supported");
 372
 373         if (m_data.srLayered &&
 374                 !context.getFragmentShadingRateProperties().layeredShadingRateAttachments)
 375                 TCU_THROW(NotSupportedError, "layeredShadingRateAttachments not supported");
 376
 377         if ((m_data.multiViewport || m_data.colorLayered) &&
 378                 !m_data.geometryShader)
 379                 context.requireDeviceFunctionality("VK_EXT_shader_viewport_index_layer");
 380
 381         if (m_data.multiView && m_data.geometryShader &&
 382                 !context.getMultiviewFeatures().multiviewGeometryShader)
 383                 TCU_THROW(NotSupportedError, "multiviewGeometryShader not supported");
 384
 385         if (m_data.interlock &&
 386                 !context.getFragmentShaderInterlockFeaturesEXT().fragmentShaderPixelInterlock)
 387                 TCU_THROW(NotSupportedError, "fragmentShaderPixelInterlock not supported");
 388
 389         if (m_data.sampleLocations)
 390         {
 391                 context.requireDeviceFunctionality("VK_EXT_sample_locations");
 392                 if (!(m_data.samples & context.getSampleLocationsPropertiesEXT().sampleLocationSampleCounts))
 393                         TCU_THROW(NotSupportedError, "samples not supported in sampleLocationSampleCounts");
 394         }
 395
 396         if (m_data.sampleMaskTest && !context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
 397                 TCU_THROW(NotSupportedError, "fragmentShadingRateWithSampleMask not supported");
 398
 399 #ifndef CTS_USES_VULKANSC
 400         if (m_data.meshShader)
 401         {
 402                 context.requireDeviceFunctionality("VK_EXT_mesh_shader");
 403                 const auto& meshFeatures = context.getMeshShaderFeaturesEXT();
 404
 405                 if (m_data.shaderWritesRate && !meshFeatures.primitiveFragmentShadingRateMeshShader)
 406                         TCU_THROW(NotSupportedError, "primitiveFragmentShadingRateMeshShader not supported");
 407
 408                 if (m_data.multiView && !meshFeatures.multiviewMeshShader)
 409                         TCU_THROW(NotSupportedError, "multiviewMeshShader not supported");
 410         }
 411
 412         checkPipelineLibraryRequirements(vki, physDev, m_data.groupParams->pipelineConstructionType);
 413
 414         if (m_data.earlyAndLateTest)
 415         {
 416                 context.requireDeviceFunctionality("VK_AMD_shader_early_and_late_fragment_tests");
 417                 if (context.getShaderEarlyAndLateFragmentTestsFeaturesAMD().shaderEarlyAndLateFragmentTests == VK_FALSE)
 418                         TCU_THROW(NotSupportedError, "shaderEarlyAndLateFragmentTests is not supported");
 419         }
 420 #endif
 421 }
 422
 423 // Error codes writted by the fragment shader
 424 enum
 425 {
 426         ERROR_NONE = 0,
 427         ERROR_FRAGCOORD_CENTER = 1,
 428         ERROR_VTG_READBACK = 2,
 429         ERROR_FRAGCOORD_DERIV = 3,
 430         ERROR_FRAGCOORD_IMPLICIT_DERIV = 4,
 431 };
 432
 433 void FSRTestCase::initPrograms (SourceCollections& programCollection) const
 434 {
 435         if (!m_data.meshShader)
 436         {
 437                 std::stringstream vss;
 438
 439                 vss <<
 440                         "#version 450 core\n"
 441                         "#extension GL_EXT_fragment_shading_rate : enable\n"
 442                         "#extension GL_ARB_shader_viewport_layer_array : enable\n"
 443                         "layout(push_constant) uniform PC {\n"
 444                         "       int shadingRate;\n"
 445                         "} pc;\n"
 446                         "layout(location = 0) in vec2 pos;\n"
 447                         "layout(location = 0) out int instanceIndex;\n"
 448                         "layout(location = 1) out int readbackok;\n"
 449                         "layout(location = 2) out float zero;\n"
 450                         "out gl_PerVertex\n"
 451                         "{\n"
 452                         "   vec4 gl_Position;\n"
 453                         "};\n"
 454                         "void main()\n"
 455                         "{\n"
 456                         "  gl_Position = vec4(pos, 0, 1);\n"
 457                         "  instanceIndex = gl_InstanceIndex;\n"
 458                         "  readbackok = 1;\n"
 459                         "  zero = 0;\n";
 460
 461                 if (m_data.shaderWritesRate)
 462                 {
 463                         vss << "  gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
 464
 465                         // Verify that we can read from the output variable
 466                         vss << "  if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
 467
 468                         if (!m_data.geometryShader)
 469                         {
 470                                 if (m_data.multiViewport)
 471                                         vss << "  gl_ViewportIndex = instanceIndex & 1;\n";
 472                                 if (m_data.colorLayered)
 473                                         vss << "  gl_Layer = ((instanceIndex & 2) >> 1);\n";
 474                         }
 475                 }
 476
 477                 vss << "}\n";
 478
 479                 programCollection.glslSources.add("vert") << glu::VertexSource(vss.str());
 480
 481                 if (m_data.geometryShader)
 482                 {
 483                         std::string writeShadingRate = "";
 484                         if (m_data.shaderWritesRate)
 485                         {
 486                                 writeShadingRate =
 487                                         "  gl_PrimitiveShadingRateEXT = pc.shadingRate;\n"
 488                                         "  if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
 489
 490                                 if (m_data.multiViewport)
 491                                         writeShadingRate += "  gl_ViewportIndex = inInstanceIndex[0] & 1;\n";
 492
 493                                 if (m_data.colorLayered)
 494                                         writeShadingRate += "  gl_Layer = (inInstanceIndex[0] & 2) >> 1;\n";
 495                         }
 496
 497                         std::stringstream gss;
 498                         gss <<
 499                                 "#version 450 core\n"
 500                                 "#extension GL_EXT_fragment_shading_rate : enable\n"
 501                                 "\n"
 502                                 "layout(push_constant) uniform PC {\n"
 503                                 "       int shadingRate;\n"
 504                                 "} pc;\n"
 505                                 "\n"
 506                                 "in gl_PerVertex\n"
 507                                 "{\n"
 508                                 "   vec4 gl_Position;\n"
 509                                 "} gl_in[3];\n"
 510                                 "\n"
 511                                 "layout(location = 0) in int inInstanceIndex[];\n"
 512                                 "layout(location = 0) out int outInstanceIndex;\n"
 513                                 "layout(location = 1) out int readbackok;\n"
 514                                 "layout(location = 2) out float zero;\n"
 515                                 "layout(triangles) in;\n"
 516                                 "layout(triangle_strip, max_vertices=3) out;\n"
 517                                 "\n"
 518                                 "out gl_PerVertex {\n"
 519                                 "   vec4 gl_Position;\n"
 520                                 "};\n"
 521                                 "\n"
 522                                 "void main(void)\n"
 523                                 "{\n"
 524                                 "   gl_Position = gl_in[0].gl_Position;\n"
 525                                 "   outInstanceIndex = inInstanceIndex[0];\n"
 526                                 "   readbackok  = 1;\n"
 527                                 "   zero = 0;\n"
 528                                 << writeShadingRate <<
 529                                 "   EmitVertex();"
 530                                 "\n"
 531                                 "   gl_Position = gl_in[1].gl_Position;\n"
 532                                 "   outInstanceIndex = inInstanceIndex[1];\n"
 533                                 "   readbackok = 1;\n"
 534                                 "   zero = 0;\n"
 535                                 << writeShadingRate <<
 536                                 "   EmitVertex();"
 537                                 "\n"
 538                                 "   gl_Position = gl_in[2].gl_Position;\n"
 539                                 "   outInstanceIndex = inInstanceIndex[2];\n"
 540                                 "   readbackok = 1;\n"
 541                                 "   zero = 0;\n"
 542                                 << writeShadingRate <<
 543                                 "   EmitVertex();"
 544                                 "}\n";
 545
 546                         programCollection.glslSources.add("geom") << glu::GeometrySource(gss.str());
 547                 }
 548         }
 549         else
 550         {
 551                 std::stringstream mss;
 552
 553                 mss <<
 554                         "#version 450 core\n"
 555                         "#extension GL_EXT_mesh_shader : enable\n"
 556                         "layout(local_size_x=3) in;\n"
 557                         "layout(triangles) out;\n"
 558                         "layout(max_vertices=3, max_primitives=1) out;\n"
 559                         "layout(push_constant, std430) uniform PC {\n"
 560                         "  int shadingRate;\n"
 561                         "  uint instanceIndex;\n"
 562                         "} pc;\n"
 563                         "layout(set=1, binding=0, std430) readonly buffer PosBuffer {\n"
 564                         "  vec2 vertexPositions[];\n"
 565                         "} pb;\n"
 566                         "layout(location = 0) flat out int instanceIndex[];\n"
 567                         "layout(location = 1) flat out int readbackok[];\n"
 568                         "layout(location = 2) out float zero[];\n";
 569
 570                 if (m_data.shaderWritesRate)
 571                 {
 572                         mss <<
 573                                 "perprimitiveEXT out gl_MeshPerPrimitiveEXT {\n"
 574                                 << (m_data.colorLayered ? "  int gl_Layer;\n" : "")
 575                                 << (m_data.multiViewport ? "  int gl_ViewportIndex;\n" : "") <<
 576                                 "  int gl_PrimitiveShadingRateEXT;\n"
 577                                 "} gl_MeshPrimitivesEXT[];\n";
 578                 }
 579
 580                 mss <<
 581                         "void main()\n"
 582                         "{\n"
 583                         "  SetMeshOutputsEXT(3u, 1u);\n"
 584                         "  const uint vertexIdx = (pc.instanceIndex * 3u + gl_LocalInvocationIndex);\n"
 585                         "  gl_MeshVerticesEXT[gl_LocalInvocationIndex].gl_Position = vec4(pb.vertexPositions[vertexIdx], 0, 1);\n"
 586                         "  if (gl_LocalInvocationIndex == 0) {\n"
 587                         "    gl_PrimitiveTriangleIndicesEXT[0] = uvec3(0, 1, 2);\n"
 588                         "  }\n"
 589                         "  instanceIndex[gl_LocalInvocationIndex] = int(pc.instanceIndex);\n"
 590                         "  readbackok[gl_LocalInvocationIndex] = 1;\n"
 591                         "  zero[gl_LocalInvocationIndex] = 0;\n";
 592
 593                 if (m_data.shaderWritesRate)
 594                 {
 595                         mss << "  gl_MeshPrimitivesEXT[0].gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
 596
 597                         // gl_MeshPerPrimitiveEXT is write-only in mesh shaders, so we cannot verify the readback operation.
 598                         //mss << "  if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
 599
 600                         if (m_data.multiViewport)
 601                                 mss << "  gl_MeshPrimitivesEXT[0].gl_ViewportIndex = int(pc.instanceIndex & 1);\n";
 602                         if (m_data.colorLayered)
 603                                 mss << "  gl_MeshPrimitivesEXT[0].gl_Layer = int((pc.instanceIndex & 2) >> 1);\n";
 604                 }
 605
 606                 mss << "}\n";
 607
 608                 const ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
 609                 programCollection.glslSources.add("mesh") << glu::MeshSource(mss.str()) << buildOptions;
 610         }
 611
 612         std::stringstream fss;
 613
 614         fss <<
 615                 "#version 450 core\n"
 616                 "#extension GL_EXT_fragment_shading_rate : enable\n"
 617                 "#extension GL_ARB_shader_stencil_export : enable\n"
 618                 "#extension GL_ARB_fragment_shader_interlock : enable\n";
 619
 620         if (m_data.earlyAndLateTest)
 621                 fss << "#extension GL_AMD_shader_early_and_late_fragment_tests : enable\n";
 622
 623         fss << "layout(location = 0) out uvec4 col0;\n"
 624                 "layout(set = 0, binding = 0) buffer Block { uint counter; } buf;\n"
 625                 "layout(set = 0, binding = 3) uniform usampler2D tex;\n"
 626                 "layout(location = 0) flat in int instanceIndex;\n"
 627                 "layout(location = 1) flat in int readbackok;\n"
 628                 "layout(location = 2) " << (m_data.sampleShadingInput ? "sample " : "") << "in float zero;\n";
 629
 630         if (m_data.earlyAndLateTest)
 631                 fss << "layout(early_and_late_fragment_tests_amd) in;\n";
 632
 633         if (m_data.fragDepth && m_data.earlyAndLateTest)
 634                 fss << "layout(depth_less) out float gl_FragDepth;\n";
 635
 636         if (m_data.fragStencil && m_data.earlyAndLateTest)
 637                 fss << "layout(stencil_ref_less_front_amd) out int gl_FragStencilRefARB;\n";
 638
 639         if (m_data.interlock)
 640                 fss << "layout(pixel_interlock_ordered) in;\n";
 641
 642         fss <<
 643                 "void main()\n"
 644                 "{\n";
 645
 646         if (m_data.interlock)
 647                 fss << "  beginInvocationInterlockARB();\n";
 648
 649         fss <<
 650                 // X component gets shading rate enum
 651                 "  col0.x = gl_ShadingRateEXT;\n"
 652                 "  col0.y = 0;\n"
 653                 // Z component gets packed primitiveID | atomic value
 654                 "  col0.z = (instanceIndex << 24) | ((atomicAdd(buf.counter, 1) + 1) & 0x00FFFFFFu);\n"
 655                 "  ivec2 fragCoordXY = ivec2(gl_FragCoord.xy);\n"
 656                 "  ivec2 fragSize = ivec2(1<<((gl_ShadingRateEXT/4)&3), 1<<(gl_ShadingRateEXT&3));\n"
 657                 // W component gets error code
 658                 "  col0.w = uint(zero)" << (m_data.sampleShadingInput ? " * gl_SampleID" : "") << ";\n"
 659                 "  if (((fragCoordXY - fragSize / 2) % fragSize) != ivec2(0,0))\n"
 660                 "    col0.w = " << ERROR_FRAGCOORD_CENTER << ";\n";
 661
 662         if (m_data.shaderWritesRate)
 663         {
 664                 fss <<
 665                         "  if (readbackok != 1)\n"
 666                         "    col0.w = " << ERROR_VTG_READBACK << ";\n";
 667         }
 668
 669         // When sample shading, gl_FragCoord is more likely to give bad derivatives,
 670         // e.g. due to a partially covered quad having some pixels center sample and
 671         // some sample at a sample location.
 672         if (!m_data.sampleShadingEnable && !m_data.sampleShadingInput)
 673         {
 674                 fss << "  if (dFdx(gl_FragCoord.xy) != ivec2(fragSize.x, 0) || dFdy(gl_FragCoord.xy) != ivec2(0, fragSize.y))\n"
 675                            "    col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (int(dFdx(gl_FragCoord.xy)) << 14) | (int(dFdx(gl_FragCoord.xy)) << 8) | " << ERROR_FRAGCOORD_DERIV << ";\n";
 676
 677                 fss << "  uint implicitDerivX = texture(tex, vec2(gl_FragCoord.x / textureSize(tex, 0).x, 0)).x;\n"
 678                            "  uint implicitDerivY = texture(tex, vec2(0, gl_FragCoord.y / textureSize(tex, 0).y)).x;\n"
 679                            "  if (implicitDerivX != fragSize.x || implicitDerivY != fragSize.y)\n"
 680                            "    col0.w = (fragSize.y << 26) | (fragSize.x << 20) | (implicitDerivY << 14) | (implicitDerivX << 8) | " << ERROR_FRAGCOORD_IMPLICIT_DERIV << ";\n";
 681         }
 682         // Y component gets sample mask value
 683         if (m_data.useSampleMaskIn)
 684                 fss << "  col0.y = gl_SampleMaskIn[0];\n";
 685
 686         if (m_data.fragDepth)
 687                 fss << "  gl_FragDepth = float(instanceIndex) / float(" << NUM_TRIANGLES << ");\n";
 688
 689         if (m_data.fragStencil)
 690                 fss << "  gl_FragStencilRefARB = instanceIndex;\n";
 691
 692         if (m_data.interlock)
 693                 fss << "  endInvocationInterlockARB();\n";
 694
 695         fss <<
 696                 "}\n";
 697
 698         programCollection.glslSources.add("frag") << glu::FragmentSource(fss.str());
 699
 700         std::stringstream css;
 701
 702         std::string fsampType = m_data.samples > 1 ?  "texture2DMSArray" :  "texture2DArray";
 703         std::string usampType = m_data.samples > 1 ? "utexture2DMSArray" : "utexture2DArray";
 704
 705         // Compute shader copies color/depth/stencil to linear layout in buffer memory
 706         css <<
 707                 "#version 450 core\n"
 708                 "#extension GL_EXT_samplerless_texture_functions : enable\n"
 709                 "layout(set = 0, binding = 1) uniform " << usampType << " colorTex;\n"
 710                 "layout(set = 0, binding = 2, std430) buffer Block0 { uvec4 b[]; } colorbuf;\n"
 711                 "layout(set = 0, binding = 4, std430) buffer Block1 { float b[]; } depthbuf;\n"
 712                 "layout(set = 0, binding = 5, std430) buffer Block2 { uint b[]; } stencilbuf;\n"
 713                 "layout(set = 0, binding = 6) uniform " << fsampType << " depthTex;\n"
 714                 "layout(set = 0, binding = 7) uniform " << usampType << " stencilTex;\n"
 715                 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
 716                 "void main()\n"
 717                 "{\n"
 718                 "   for (int i = 0; i < " << m_data.samples << "; ++i) {\n"
 719                 "      uint idx = ((gl_GlobalInvocationID.z * " << m_data.framebufferDim.height << " + gl_GlobalInvocationID.y) * " << m_data.framebufferDim.width << " + gl_GlobalInvocationID.x) * " << m_data.samples << " + i;\n"
 720                 "      colorbuf.b[idx] = texelFetch(colorTex, ivec3(gl_GlobalInvocationID.xyz), i);\n";
 721
 722         if (m_data.fragDepth)
 723                 css << "      depthbuf.b[idx] = texelFetch(depthTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
 724
 725         if (m_data.fragStencil)
 726                 css << "      stencilbuf.b[idx] = texelFetch(stencilTex, ivec3(gl_GlobalInvocationID.xyz), i).x;\n";
 727
 728         css <<
 729                 "   }\n"
 730                 "}\n";
 731
 732         programCollection.glslSources.add("comp") << glu::ComputeSource(css.str());
 733 }
 734
 735 TestInstance* FSRTestCase::createInstance (Context& context) const
 736 {
 737         return new FSRTestInstance(context, m_data);
 738 }
 739
 740 deInt32 FSRTestInstance::ShadingRateExtentToEnum(VkExtent2D ext) const
 741 {
 742         ext.width = deCtz32(ext.width);
 743         ext.height = deCtz32(ext.height);
 744
 745         return (ext.width << 2) | ext.height;
 746 }
 747
 748 VkExtent2D FSRTestInstance::ShadingRateEnumToExtent(deInt32 rate) const
 749 {
 750         VkExtent2D ret;
 751         ret.width = 1 << ((rate/4) & 3);
 752         ret.height = 1 << (rate & 3);
 753
 754         return ret;
 755 }
 756
 757 VkExtent2D FSRTestInstance::Combine(VkExtent2D ext0, VkExtent2D ext1, VkFragmentShadingRateCombinerOpKHR comb) const
 758 {
 759         VkExtent2D ret;
 760         switch (comb)
 761         {
 762         default:
 763                 DE_ASSERT(0);
 764                 // fallthrough
 765         case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
 766                 return ext0;
 767         case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR:
 768                 return ext1;
 769         case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR:
 770                 ret = { de::min(ext0.width, ext1.width), de::min(ext0.height, ext1.height) };
 771                 return ret;
 772         case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR:
 773                 ret = { de::max(ext0.width, ext1.width), de::max(ext0.height, ext1.height) };
 774                 return ret;
 775         case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR:
 776                 ret = { ext0.width * ext1.width, ext0.height * ext1.height };
 777                 if (!m_shadingRateProperties.fragmentShadingRateStrictMultiplyCombiner)
 778                 {
 779                         if (ext0.width == 1 && ext1.width == 1)
 780                                 ret.width = 2;
 781                         if (ext0.height == 1 && ext1.height == 1)
 782                                 ret.height = 2;
 783                 }
 784                 return ret;
 785         }
 786 }
 787
 788 deInt32 FSRTestInstance::Simulate(deInt32 rate0, deInt32 rate1, deInt32 rate2)
 789 {
 790         deInt32 &cachedRate = m_simulateCache[(rate2*m_simulateValueCount + rate1)*m_simulateValueCount + rate0];
 791         if (cachedRate != ~0)
 792                 return cachedRate;
 793
 794         VkExtent2D extent0 = ShadingRateEnumToExtent(rate0);
 795         VkExtent2D extent1 = ShadingRateEnumToExtent(rate1);
 796         VkExtent2D extent2 = ShadingRateEnumToExtent(rate2);
 797
 798         deInt32 finalMask = 0;
 799         // Simulate once for implementations that don't allow swapping rate xy,
 800         // and once for those that do. Any of those results is allowed.
 801         for (deUint32 allowSwap = 0; allowSwap <= 1; ++allowSwap)
 802         {
 803                 // Combine rate 0 and 1, get a mask of possible clamped rates
 804                 VkExtent2D intermed = Combine(extent0, extent1, m_data.combinerOp[0]);
 805                 deInt32 intermedMask = ShadingRateExtentToClampedMask(intermed, allowSwap == 1);
 806
 807                 // For each clamped rate, combine that with rate 2 and accumulate the possible clamped rates
 808                 for (int i = 0; i < 16; ++i)
 809                 {
 810                         if (intermedMask & (1<<i))
 811                         {
 812                                 VkExtent2D final = Combine(ShadingRateEnumToExtent(i), extent2, m_data.combinerOp[1]);
 813                                 finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
 814                         }
 815                 }
 816                 {
 817                         // unclamped intermediate value is also permitted
 818                         VkExtent2D final = Combine(intermed, extent2, m_data.combinerOp[1]);
 819                         finalMask |= ShadingRateExtentToClampedMask(final, allowSwap == 1);
 820                 }
 821         }
 822
 823         if (Force1x1())
 824                 finalMask = 0x1;
 825
 826         cachedRate = finalMask;
 827         return finalMask;
 828 }
 829
 830 // If a rate is not valid (<=4x4), clamp it to something valid.
 831 // This is only used for "inputs" to the system, not to mimic
 832 // how the implementation internally clamps intermediate values.
 833 VkExtent2D FSRTestInstance::SanitizeExtent(VkExtent2D ext) const
 834 {
 835         DE_ASSERT(ext.width > 0 && ext.height > 0);
 836
 837         ext.width = de::min(ext.width, 4u);
 838         ext.height = de::min(ext.height, 4u);
 839
 840         return ext;
 841 }
 842
 843 // Map an extent to a mask of all modes smaller than or equal to it in either dimension
 844 deInt32 FSRTestInstance::ShadingRateExtentToClampedMask(VkExtent2D ext, bool allowSwap) const
 845 {
 846         deUint32 desiredSize = ext.width * ext.height;
 847
 848         deInt32 mask = 0;
 849
 850         while (desiredSize > 0)
 851         {
 852                 // First, find modes that maximize the area
 853                 for (deUint32 i = 0; i < m_supportedFragmentShadingRateCount; ++i)
 854                 {
 855                         const VkPhysicalDeviceFragmentShadingRateKHR &supportedRate = m_supportedFragmentShadingRates[i];
 856                         if ((supportedRate.sampleCounts & m_data.samples) &&
 857                                 supportedRate.fragmentSize.width * supportedRate.fragmentSize.height == desiredSize &&
 858                                 ((supportedRate.fragmentSize.width  <= ext.width && supportedRate.fragmentSize.height <= ext.height) ||
 859                                  (supportedRate.fragmentSize.height <= ext.width && supportedRate.fragmentSize.width  <= ext.height && allowSwap)))
 860                         {
 861                                 mask |= 1 << ShadingRateExtentToEnum(supportedRate.fragmentSize);
 862                         }
 863                 }
 864                 if (mask)
 865                 {
 866                         // Amongst the modes that maximize the area, pick the ones that
 867                         // minimize the aspect ratio. Prefer ratio of 1, then 2, then 4.
 868                         // 1x1 = 0, 2x2 = 5, 4x4 = 10
 869                         static const deUint32 aspectMaskRatio1 = 0x421;
 870                         // 2x1 = 4, 1x2 = 1, 4x2 = 9, 2x4 = 6
 871                         static const deUint32 aspectMaskRatio2 = 0x252;
 872                         // 4x1 = 8, 1x4 = 2,
 873                         static const deUint32 aspectMaskRatio4 = 0x104;
 874
 875                         if (mask & aspectMaskRatio1)
 876                         {
 877                                 mask &= aspectMaskRatio1;
 878                                 break;
 879                         }
 880                         if (mask & aspectMaskRatio2)
 881                         {
 882                                 mask &= aspectMaskRatio2;
 883                                 break;
 884                         }
 885                         if (mask & aspectMaskRatio4)
 886                         {
 887                                 mask &= aspectMaskRatio4;
 888                                 break;
 889                         }
 890                         DE_ASSERT(0);
 891                 }
 892                 desiredSize /= 2;
 893         }
 894
 895         return mask;
 896 }
 897
 898
 899 deInt32 FSRTestInstance::SanitizeRate(deInt32 rate) const
 900 {
 901         VkExtent2D extent = ShadingRateEnumToExtent(rate);
 902
 903         extent = SanitizeExtent(extent);
 904
 905         return ShadingRateExtentToEnum(extent);
 906 }
 907
 908 // Map primID % 9 to primitive shading rate
 909 deInt32 FSRTestInstance::PrimIDToPrimitiveShadingRate(deInt32 primID)
 910 {
 911         deInt32 &cachedRate = m_primIDToPrimitiveShadingRate[primID];
 912         if (cachedRate != ~0)
 913                 return cachedRate;
 914
 915         VkExtent2D extent;
 916         extent.width = 1 << (primID % 3);
 917         extent.height = 1 << ((primID/3) % 3);
 918
 919         cachedRate = ShadingRateExtentToEnum(extent);
 920         return cachedRate;
 921 }
 922
 923 // Map primID / 9 to pipeline shading rate
 924 deInt32 FSRTestInstance::PrimIDToPipelineShadingRate(deInt32 primID)
 925 {
 926         deInt32 &cachedRate = m_primIDToPipelineShadingRate[primID];
 927         if (cachedRate != ~0)
 928                 return cachedRate;
 929
 930         primID /= 9;
 931         VkExtent2D extent;
 932         extent.width = 1 << (primID % 3);
 933         extent.height = 1 << ((primID/3) % 3);
 934
 935         cachedRate = ShadingRateExtentToEnum(extent);
 936         return cachedRate;
 937 }
 938
 939 static de::MovePtr<BufferWithMemory> CreateCachedBuffer(const vk::DeviceInterface&              vk,
 940                                                                                                                 const vk::VkDevice                              device,
 941                                                                                                                 vk::Allocator&                                  allocator,
 942                                                                                                                 const vk::VkBufferCreateInfo&   bufferCreateInfo)
 943 {
 944         try
 945         {
 946                 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
 947                         vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible | MemoryRequirement::Cached));
 948         }
 949         catch (const tcu::NotSupportedError&)
 950         {
 951                 return de::MovePtr<BufferWithMemory>(new BufferWithMemory(
 952                         vk, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible));
 953         }
 954 }
 955
 956 tcu::TestStatus FSRTestInstance::iterate (void)
 957 {
 958         const DeviceInterface&  vk                                              = m_context.getDeviceInterface();
 959         const VkDevice                  device                                  = m_context.getDevice();
 960         tcu::TestLog&                   log                                             = m_context.getTestContext().getLog();
 961         Allocator&                              allocator                               = m_context.getDefaultAllocator();
 962         VkFlags                                 allShaderStages                 = VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
 963         VkFlags                                 allPipelineStages               = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
 964                                                                                                           VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
 965                                                                                                           VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
 966                                                                                                           VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
 967                                                                                                           VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
 968                                                                                                           VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
 969         const VkFormat                  cbFormat                                = VK_FORMAT_R32G32B32A32_UINT;
 970         VkFormat                                dsFormat                                = VK_FORMAT_UNDEFINED;
 971         const auto                              vertBufferUsage                 = (m_data.meshShader ? VK_BUFFER_USAGE_STORAGE_BUFFER_BIT : VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
 972
 973         if (m_data.meshShader)
 974         {
 975 #ifndef CTS_USES_VULKANSC
 976                 allShaderStages |= VK_SHADER_STAGE_MESH_BIT_EXT;
 977                 allPipelineStages |= VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
 978 #else
 979                 DE_ASSERT(false);
 980 #endif // CTS_USES_VULKANSC
 981         }
 982         else
 983         {
 984                 allShaderStages |= VK_SHADER_STAGE_VERTEX_BIT;
 985                 allPipelineStages |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
 986
 987                 if (m_data.geometryShader)
 988                 {
 989                         allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
 990                         allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
 991                 }
 992         }
 993
 994         if (m_data.useDepthStencil)
 995         {
 996                 VkFormatProperties formatProps;
 997                 m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProps);
 998                 if (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
 999                 {
1000                         dsFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
1001                 }
1002                 else
1003                 {
1004                         dsFormat = VK_FORMAT_D24_UNORM_S8_UINT;
1005                 }
1006         }
1007
1008         deRandom rnd;
1009         deRandom_init(&rnd, m_data.seed);
1010
1011         qpTestResult res = QP_TEST_RESULT_PASS;
1012         deUint32 numUnexpected1x1Samples = 0;
1013         deUint32 numTotalSamples = 0;
1014
1015         enum AttachmentModes
1016         {
1017                 ATTACHMENT_MODE_DEFAULT = 0,
1018                 ATTACHMENT_MODE_LAYOUT_OPTIMAL,
1019                 ATTACHMENT_MODE_IMAGELESS,
1020                 ATTACHMENT_MODE_2DARRAY,
1021                 ATTACHMENT_MODE_TILING_LINEAR,
1022
1023                 ATTACHMENT_MODE_COUNT,
1024         };
1025
1026         deUint32 numSRLayers = m_data.srLayered ? 2u : 1u;
1027
1028         VkExtent2D minFragmentShadingRateAttachmentTexelSize = {1, 1};
1029         VkExtent2D maxFragmentShadingRateAttachmentTexelSize = {1, 1};
1030         deUint32 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = 1;
1031         if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate)
1032         {
1033                 minFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().minFragmentShadingRateAttachmentTexelSize;
1034                 maxFragmentShadingRateAttachmentTexelSize = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSize;
1035                 maxFragmentShadingRateAttachmentTexelSizeAspectRatio = m_context.getFragmentShadingRateProperties().maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
1036         }
1037
1038         VkDeviceSize atomicBufferSize = sizeof(deUint32);
1039
1040         de::MovePtr<BufferWithMemory> atomicBuffer;
1041         atomicBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
1042                 vk, device, allocator, makeBufferCreateInfo(atomicBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
1043
1044         deUint32 *abuf = (deUint32 *)atomicBuffer->getAllocation().getHostPtr();
1045
1046         // NUM_TRIANGLES triangles, 3 vertices, 2 components of float position
1047         VkDeviceSize vertexBufferSize = NUM_TRIANGLES * 3 * 2 * sizeof(float);
1048
1049         de::MovePtr<BufferWithMemory> vertexBuffer;
1050         vertexBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
1051                 vk, device, allocator, makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | vertBufferUsage), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
1052
1053         float *vbuf = (float *)vertexBuffer->getAllocation().getHostPtr();
1054         for (deInt32 i = 0; i < (deInt32)(vertexBufferSize / sizeof(float)); ++i)
1055         {
1056                 vbuf[i] = deRandom_getFloat(&rnd)*2.0f - 1.0f;
1057         }
1058         flushAlloc(vk, device, vertexBuffer->getAllocation());
1059
1060         VkDeviceSize colorOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * 4 * sizeof(deUint32) * m_data.numColorLayers;
1061         de::MovePtr<BufferWithMemory> colorOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(colorOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
1062
1063         VkDeviceSize depthOutputBufferSize = 0, stencilOutputBufferSize = 0;
1064         de::MovePtr<BufferWithMemory> depthOutputBuffer, stencilOutputBuffer;
1065         if (m_data.useDepthStencil)
1066         {
1067                 depthOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(float) * m_data.numColorLayers;
1068                 depthOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(depthOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
1069
1070                 stencilOutputBufferSize = m_data.framebufferDim.width * m_data.framebufferDim.height * m_data.samples * sizeof(deUint32) * m_data.numColorLayers;
1071                 stencilOutputBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(stencilOutputBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT));
1072         }
1073
1074         deUint32 minSRTexelWidth = minFragmentShadingRateAttachmentTexelSize.width;
1075         deUint32 minSRTexelHeight = minFragmentShadingRateAttachmentTexelSize.height;
1076         deUint32 maxSRWidth = (m_data.framebufferDim.width + minSRTexelWidth - 1) / minSRTexelWidth;
1077         deUint32 maxSRHeight = (m_data.framebufferDim.height + minSRTexelHeight - 1) / minSRTexelHeight;
1078
1079         // max size over all formats
1080         VkDeviceSize srFillBufferSize = numSRLayers * maxSRWidth * maxSRHeight * 32/*4 component 64-bit*/;
1081         de::MovePtr<BufferWithMemory> srFillBuffer;
1082         deUint8 *fillPtr = DE_NULL;
1083         if (m_data.useAttachment())
1084         {
1085                 srFillBuffer = CreateCachedBuffer(vk, device, allocator, makeBufferCreateInfo(srFillBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1086                 fillPtr = (deUint8 *)srFillBuffer->getAllocation().getHostPtr();
1087         }
1088
1089         de::MovePtr<ImageWithMemory> cbImage;
1090         Move<VkImageView> cbImageView;
1091         {
1092                 const VkImageCreateInfo                 imageCreateInfo                 =
1093                 {
1094                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType                      sType;
1095                         DE_NULL,                                                                // const void*                          pNext;
1096                         (VkImageCreateFlags)0u,                                 // VkImageCreateFlags           flags;
1097                         VK_IMAGE_TYPE_2D,                                               // VkImageType                          imageType;
1098                         cbFormat,                                                               // VkFormat                                     format;
1099                         {
1100                                 m_data.framebufferDim.width,            // deUint32     width;
1101                                 m_data.framebufferDim.height,           // deUint32     height;
1102                                 1u                                                                      // deUint32     depth;
1103                         },                                                                              // VkExtent3D                           extent;
1104                         1u,                                                                             // deUint32                                     mipLevels;
1105                         m_data.numColorLayers,                                  // deUint32                                     arrayLayers;
1106                         m_data.samples,                                                 // VkSampleCountFlagBits        samples;
1107                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                        tiling;
1108                         cbUsage,                                                                // VkImageUsageFlags            usage;
1109                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                        sharingMode;
1110                         0u,                                                                             // deUint32                                     queueFamilyIndexCount;
1111                         DE_NULL,                                                                // const deUint32*                      pQueueFamilyIndices;
1112                         VK_IMAGE_LAYOUT_UNDEFINED                               // VkImageLayout                        initialLayout;
1113                 };
1114                 cbImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1115                         vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1116
1117                 VkImageViewCreateInfo           imageViewCreateInfo             =
1118                 {
1119                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                      sType;
1120                         DE_NULL,                                                                        // const void*                          pNext;
1121                         (VkImageViewCreateFlags)0u,                                     // VkImageViewCreateFlags       flags;
1122                         **cbImage,                                                                      // VkImage                                      image;
1123                         VK_IMAGE_VIEW_TYPE_2D_ARRAY,                            // VkImageViewType                      viewType;
1124                         cbFormat,                                                                       // VkFormat                                     format;
1125                         {
1126                                 VK_COMPONENT_SWIZZLE_R,                                 // VkComponentSwizzle   r;
1127                                 VK_COMPONENT_SWIZZLE_G,                                 // VkComponentSwizzle   g;
1128                                 VK_COMPONENT_SWIZZLE_B,                                 // VkComponentSwizzle   b;
1129                                 VK_COMPONENT_SWIZZLE_A                                  // VkComponentSwizzle   a;
1130                         },                                                                                      // VkComponentMapping            components;
1131                         {
1132                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask;
1133                                 0u,                                                                             // deUint32                             baseMipLevel;
1134                                 1u,                                                                             // deUint32                             levelCount;
1135                                 0u,                                                                             // deUint32                             baseArrayLayer;
1136                                 m_data.numColorLayers                                   // deUint32                             layerCount;
1137                         }                                                                                       // VkImageSubresourceRange      subresourceRange;
1138                 };
1139                 cbImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1140         }
1141
1142         de::MovePtr<ImageWithMemory> dsImage;
1143         Move<VkImageView> dsImageView, dImageView, sImageView;
1144
1145         if (m_data.useDepthStencil)
1146         {
1147                 const VkImageCreateInfo                 imageCreateInfo                 =
1148                 {
1149                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType                      sType;
1150                         DE_NULL,                                                                // const void*                          pNext;
1151                         (VkImageCreateFlags)0u,                                 // VkImageCreateFlags           flags;
1152                         VK_IMAGE_TYPE_2D,                                               // VkImageType                          imageType;
1153                         dsFormat,                                                               // VkFormat                                     format;
1154                         {
1155                                 m_data.framebufferDim.width,            // deUint32     width;
1156                                 m_data.framebufferDim.height,           // deUint32     height;
1157                                 1u                                                                      // deUint32     depth;
1158                         },                                                                              // VkExtent3D                           extent;
1159                         1u,                                                                             // deUint32                                     mipLevels;
1160                         m_data.numColorLayers,                                  // deUint32                                     arrayLayers;
1161                         m_data.samples,                                                 // VkSampleCountFlagBits        samples;
1162                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                        tiling;
1163                         dsUsage,                                                                // VkImageUsageFlags            usage;
1164                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                        sharingMode;
1165                         0u,                                                                             // deUint32                                     queueFamilyIndexCount;
1166                         DE_NULL,                                                                // const deUint32*                      pQueueFamilyIndices;
1167                         VK_IMAGE_LAYOUT_UNDEFINED                               // VkImageLayout                        initialLayout;
1168                 };
1169                 dsImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1170                         vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1171
1172                 VkImageViewCreateInfo           imageViewCreateInfo             =
1173                 {
1174                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                      sType;
1175                         DE_NULL,                                                                        // const void*                          pNext;
1176                         (VkImageViewCreateFlags)0u,                                     // VkImageViewCreateFlags       flags;
1177                         **dsImage,                                                                      // VkImage                                      image;
1178                         VK_IMAGE_VIEW_TYPE_2D_ARRAY,                            // VkImageViewType                      viewType;
1179                         dsFormat,                                                                       // VkFormat                                     format;
1180                         {
1181                                 VK_COMPONENT_SWIZZLE_R,                                 // VkComponentSwizzle   r;
1182                                 VK_COMPONENT_SWIZZLE_G,                                 // VkComponentSwizzle   g;
1183                                 VK_COMPONENT_SWIZZLE_B,                                 // VkComponentSwizzle   b;
1184                                 VK_COMPONENT_SWIZZLE_A                                  // VkComponentSwizzle   a;
1185                         },                                                                                      // VkComponentMapping            components;
1186                         {
1187                                 VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT,        // VkImageAspectFlags   aspectMask;
1188                                 0u,                                                                             // deUint32                             baseMipLevel;
1189                                 1u,                                                                             // deUint32                             levelCount;
1190                                 0u,                                                                             // deUint32                             baseArrayLayer;
1191                                 m_data.numColorLayers                                   // deUint32                             layerCount;
1192                         }                                                                                       // VkImageSubresourceRange      subresourceRange;
1193                 };
1194                 dsImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1195                 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1196                 dImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1197                 imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1198                 sImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1199         }
1200
1201         // Image used to test implicit derivative calculations.
1202         // Filled with a value of 1<<lod.
1203         de::MovePtr<ImageWithMemory> derivImage;
1204         Move<VkImageView> derivImageView;
1205         VkImageUsageFlags derivUsage = VK_IMAGE_USAGE_SAMPLED_BIT |
1206                                                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1207         deUint32 derivNumLevels;
1208         {
1209                 deUint32 maxDim = de::max(m_context.getFragmentShadingRateProperties().maxFragmentSize.width, m_context.getFragmentShadingRateProperties().maxFragmentSize.height);
1210                 derivNumLevels = 1 + deCtz32(maxDim);
1211                 const VkImageCreateInfo                 imageCreateInfo                 =
1212                 {
1213                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType                      sType;
1214                         DE_NULL,                                                                // const void*                          pNext;
1215                         (VkImageCreateFlags)0u,                                 // VkImageCreateFlags           flags;
1216                         VK_IMAGE_TYPE_2D,                                               // VkImageType                          imageType;
1217                         VK_FORMAT_R32_UINT,                                             // VkFormat                                     format;
1218                         {
1219                                 m_context.getFragmentShadingRateProperties().maxFragmentSize.width,             // deUint32     width;
1220                                 m_context.getFragmentShadingRateProperties().maxFragmentSize.height,    // deUint32     height;
1221                                 1u                                                                      // deUint32     depth;
1222                         },                                                                              // VkExtent3D                           extent;
1223                         derivNumLevels,                                                 // deUint32                                     mipLevels;
1224                         1u,                                                                             // deUint32                                     arrayLayers;
1225                         VK_SAMPLE_COUNT_1_BIT,                                  // VkSampleCountFlagBits        samples;
1226                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                        tiling;
1227                         derivUsage,                                                             // VkImageUsageFlags            usage;
1228                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                        sharingMode;
1229                         0u,                                                                             // deUint32                                     queueFamilyIndexCount;
1230                         DE_NULL,                                                                // const deUint32*                      pQueueFamilyIndices;
1231                         VK_IMAGE_LAYOUT_UNDEFINED                               // VkImageLayout                        initialLayout;
1232                 };
1233                 derivImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1234                         vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1235
1236                 VkImageViewCreateInfo           imageViewCreateInfo             =
1237                 {
1238                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                      sType;
1239                         DE_NULL,                                                                        // const void*                          pNext;
1240                         (VkImageViewCreateFlags)0u,                                     // VkImageViewCreateFlags       flags;
1241                         **derivImage,                                                           // VkImage                                      image;
1242                         VK_IMAGE_VIEW_TYPE_2D,                                          // VkImageViewType                      viewType;
1243                         VK_FORMAT_R32_UINT,                                                     // VkFormat                                     format;
1244                         {
1245                                 VK_COMPONENT_SWIZZLE_R,                                 // VkComponentSwizzle   r;
1246                                 VK_COMPONENT_SWIZZLE_G,                                 // VkComponentSwizzle   g;
1247                                 VK_COMPONENT_SWIZZLE_B,                                 // VkComponentSwizzle   b;
1248                                 VK_COMPONENT_SWIZZLE_A                                  // VkComponentSwizzle   a;
1249                         },                                                                                      // VkComponentMapping            components;
1250                         {
1251                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask;
1252                                 0u,                                                                             // deUint32                             baseMipLevel;
1253                                 derivNumLevels,                                                 // deUint32                             levelCount;
1254                                 0u,                                                                             // deUint32                             baseArrayLayer;
1255                                 1u                                                                              // deUint32                             layerCount;
1256                         }                                                                                       // VkImageSubresourceRange      subresourceRange;
1257                 };
1258                 derivImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1259         }
1260
1261         // sampler used with derivImage
1262         const struct VkSamplerCreateInfo                samplerInfo     =
1263         {
1264                 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,          // sType
1265                 DE_NULL,                                                                        // pNext
1266                 0u,                                                                                     // flags
1267                 VK_FILTER_NEAREST,                                                      // magFilter
1268                 VK_FILTER_NEAREST,                                                      // minFilter
1269                 VK_SAMPLER_MIPMAP_MODE_NEAREST,                         // mipmapMode
1270                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // addressModeU
1271                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // addressModeV
1272                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // addressModeW
1273                 0.0f,                                                                           // mipLodBias
1274                 VK_FALSE,                                                                       // anisotropyEnable
1275                 1.0f,                                                                           // maxAnisotropy
1276                 DE_FALSE,                                                                       // compareEnable
1277                 VK_COMPARE_OP_ALWAYS,                                           // compareOp
1278                 0.0f,                                                                           // minLod
1279                 (float)derivNumLevels,                                          // maxLod
1280                 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,          // borderColor
1281                 VK_FALSE,                                                                       // unnormalizedCoords
1282         };
1283
1284         Move<VkSampler>                 sampler = createSampler(vk, device, &samplerInfo);
1285
1286         std::vector<Move<vk::VkDescriptorSetLayout>> descriptorSetLayouts;
1287         const VkDescriptorSetLayoutCreateFlags layoutCreateFlags = 0;
1288
1289         const VkDescriptorSetLayoutBinding bindings[] =
1290         {
1291                 {
1292                         0u,                                                                             // binding
1293                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,              // descriptorType
1294                         1u,                                                                             // descriptorCount
1295                         allShaderStages,                                                // stageFlags
1296                         DE_NULL,                                                                // pImmutableSamplers
1297                 },
1298                 {
1299                         1u,                                                                             // binding
1300                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,               // descriptorType
1301                         1u,                                                                             // descriptorCount
1302                         allShaderStages,                                                // stageFlags
1303                         DE_NULL,                                                                // pImmutableSamplers
1304                 },
1305                 {
1306                         2u,                                                                             // binding
1307                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,              // descriptorType
1308                         1u,                                                                             // descriptorCount
1309                         allShaderStages,                                                // stageFlags
1310                         DE_NULL,                                                                // pImmutableSamplers
1311                 },
1312                 {
1313                         3u,                                                                             // binding
1314                         VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,      // descriptorType
1315                         1u,                                                                             // descriptorCount
1316                         allShaderStages,                                                // stageFlags
1317                         DE_NULL,                                                                // pImmutableSamplers
1318                 },
1319                 {
1320                         4u,                                                                             // binding
1321                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,              // descriptorType
1322                         1u,                                                                             // descriptorCount
1323                         allShaderStages,                                                // stageFlags
1324                         DE_NULL,                                                                // pImmutableSamplers
1325                 },
1326                 {
1327                         5u,                                                                             // binding
1328                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,              // descriptorType
1329                         1u,                                                                             // descriptorCount
1330                         allShaderStages,                                                // stageFlags
1331                         DE_NULL,                                                                // pImmutableSamplers
1332                 },
1333                 {
1334                         6u,                                                                             // binding
1335                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,               // descriptorType
1336                         1u,                                                                             // descriptorCount
1337                         allShaderStages,                                                // stageFlags
1338                         DE_NULL,                                                                // pImmutableSamplers
1339                 },
1340                 {
1341                         7u,                                                                             // binding
1342                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,               // descriptorType
1343                         1u,                                                                             // descriptorCount
1344                         allShaderStages,                                                // stageFlags
1345                         DE_NULL,                                                                // pImmutableSamplers
1346                 },
1347         };
1348
1349         // Create a layout and allocate a descriptor set for it.
1350         const VkDescriptorSetLayoutCreateInfo setLayoutCreateInfo =
1351         {
1352                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,        // sType
1353                 DE_NULL,                                                                                                        // pNext
1354                 layoutCreateFlags,                                                                                      // flags
1355                 static_cast<uint32_t>(de::arrayLength(bindings)),                       // bindingCount
1356                 &bindings[0]                                                                                            // pBindings
1357         };
1358
1359         descriptorSetLayouts.push_back(vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo));
1360
1361         // Mesh shaders use set 1 binding 0 as the vertex buffer.
1362         if (m_data.meshShader)
1363         {
1364 #ifndef CTS_USES_VULKANSC
1365                 const VkDescriptorSetLayoutBinding extraBinding =
1366                 {
1367                         0u,                                                                             // binding
1368                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,              // descriptorType
1369                         1u,                                                                             // descriptorCount
1370                         VK_SHADER_STAGE_MESH_BIT_EXT,                   // stageFlags
1371                         DE_NULL,                                                                // pImmutableSamplers
1372                 };
1373
1374                 const VkDescriptorSetLayoutCreateInfo extraSetLayoutCreateInfo =
1375                 {
1376                         vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,        // sType
1377                         DE_NULL,                                                                                                        // pNext
1378                         layoutCreateFlags,                                                                                      // flags
1379                         1u,                                                                                                                     // bindingCount
1380                         &extraBinding,                                                                                          // pBindings
1381                 };
1382
1383                 descriptorSetLayouts.push_back(vk::createDescriptorSetLayout(vk, device, &extraSetLayoutCreateInfo));
1384 #else
1385                 DE_ASSERT(false);
1386 #endif // CTS_USES_VULKANSC
1387         }
1388
1389         const uint32_t                                                  numConstants                                    = (m_data.meshShader ? 2u : 1u);
1390         const uint32_t                                                  pushConstantSize                                = (static_cast<uint32_t>(sizeof(deInt32)) * numConstants);
1391         const VkPushConstantRange                               pushConstantRange                               =
1392         {
1393                 allShaderStages,        // VkShaderStageFlags                                   stageFlags;
1394                 0u,                                     // deUint32                                                             offset;
1395                 pushConstantSize,       // deUint32                                                             size;
1396         };
1397
1398         std::vector<VkDescriptorSetLayout> descriptorSetLayoutsRaw;
1399         descriptorSetLayoutsRaw.reserve(descriptorSetLayouts.size());
1400
1401         std::transform(begin(descriptorSetLayouts), end(descriptorSetLayouts), std::back_inserter(descriptorSetLayoutsRaw),
1402                 [](const Move<VkDescriptorSetLayout>& elem) { return elem.get(); });
1403
1404         const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1405         {
1406                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                          // sType
1407                 DE_NULL,                                                                                                        // pNext
1408                 (VkPipelineLayoutCreateFlags)0,
1409                 static_cast<uint32_t>(descriptorSetLayoutsRaw.size()),          // setLayoutCount
1410                 de::dataOrNull(descriptorSetLayoutsRaw),                                        // pSetLayouts
1411                 1u,                                                                                                                     // pushConstantRangeCount
1412                 &pushConstantRange,                                                                                     // pPushConstantRanges
1413         };
1414
1415         Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo, NULL);
1416
1417         const Unique<VkShaderModule>    cs                                              (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
1418
1419         const VkPipelineShaderStageCreateInfo   csShaderCreateInfo =
1420         {
1421                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1422                 DE_NULL,
1423                 (VkPipelineShaderStageCreateFlags)0,
1424                 VK_SHADER_STAGE_COMPUTE_BIT,                                                            // stage
1425                 *cs,                                                                                                            // shader
1426                 "main",
1427                 DE_NULL,                                                                                                        // pSpecializationInfo
1428         };
1429
1430         const VkComputePipelineCreateInfo               pipelineCreateInfo =
1431         {
1432                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1433                 DE_NULL,
1434                 0u,                                                                                                                     // flags
1435                 csShaderCreateInfo,                                                                                     // cs
1436                 *pipelineLayout,                                                                                        // layout
1437                 (vk::VkPipeline)0,                                                                                      // basePipelineHandle
1438                 0u,                                                                                                                     // basePipelineIndex
1439         };
1440         Move<VkPipeline> computePipeline = createComputePipeline(vk, device, DE_NULL, &pipelineCreateInfo, NULL);
1441
1442         for (deUint32 modeIdx = 0; modeIdx < ATTACHMENT_MODE_COUNT; ++modeIdx)
1443         {
1444                 // If we're not using an attachment, don't test all the different attachment modes
1445                 if (modeIdx != ATTACHMENT_MODE_DEFAULT && !m_data.useAttachment())
1446                         continue;
1447
1448                 // Consider all uint formats possible
1449                 static const VkFormat srFillFormats[] =
1450                 {
1451                         VK_FORMAT_R8_UINT,
1452                         VK_FORMAT_R8G8_UINT,
1453                         VK_FORMAT_R8G8B8_UINT,
1454                         VK_FORMAT_R8G8B8A8_UINT,
1455                         VK_FORMAT_R16_UINT,
1456                         VK_FORMAT_R16G16_UINT,
1457                         VK_FORMAT_R16G16B16_UINT,
1458                         VK_FORMAT_R16G16B16A16_UINT,
1459                         VK_FORMAT_R32_UINT,
1460                         VK_FORMAT_R32G32_UINT,
1461                         VK_FORMAT_R32G32B32_UINT,
1462                         VK_FORMAT_R32G32B32A32_UINT,
1463                         VK_FORMAT_R64_UINT,
1464                         VK_FORMAT_R64G64_UINT,
1465                         VK_FORMAT_R64G64B64_UINT,
1466                         VK_FORMAT_R64G64B64A64_UINT,
1467                 };
1468                 // Only test all formats in the default mode
1469                 deUint32 numFillFormats = modeIdx == ATTACHMENT_MODE_DEFAULT ? (deUint32)(sizeof(srFillFormats)/sizeof(srFillFormats[0])) : 1u;
1470
1471                 // Iterate over all supported tile sizes and formats
1472                 for (deUint32 srTexelWidth  = minFragmentShadingRateAttachmentTexelSize.width;
1473                                           srTexelWidth <= maxFragmentShadingRateAttachmentTexelSize.width;
1474                                           srTexelWidth *= 2)
1475                 for (deUint32 srTexelHeight  = minFragmentShadingRateAttachmentTexelSize.height;
1476                                           srTexelHeight <= maxFragmentShadingRateAttachmentTexelSize.height;
1477                                           srTexelHeight *= 2)
1478                 for (deUint32 formatIdx = 0; formatIdx < numFillFormats; ++formatIdx)
1479                 {
1480                         deUint32 aspectRatio = (srTexelHeight > srTexelWidth) ? (srTexelHeight / srTexelWidth) : (srTexelWidth / srTexelHeight);
1481                         if (aspectRatio > maxFragmentShadingRateAttachmentTexelSizeAspectRatio)
1482                                 continue;
1483
1484                         // Go through the loop only once when not using an attachment
1485                         if (!m_data.useAttachment() &&
1486                                 (srTexelWidth != minFragmentShadingRateAttachmentTexelSize.width ||
1487                                  srTexelHeight != minFragmentShadingRateAttachmentTexelSize.height ||
1488                                  formatIdx != 0))
1489                                  continue;
1490
1491                         bool imagelessFB = modeIdx == ATTACHMENT_MODE_IMAGELESS;
1492
1493                         deUint32 srWidth = (m_data.framebufferDim.width + srTexelWidth - 1) / srTexelWidth;
1494                         deUint32 srHeight = (m_data.framebufferDim.height + srTexelHeight - 1) / srTexelHeight;
1495
1496                         VkFormat srFormat = srFillFormats[formatIdx];
1497                         deUint32 srFillBpp = tcu::getPixelSize(mapVkFormat(srFormat));
1498
1499                         VkImageLayout srLayout = modeIdx == ATTACHMENT_MODE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR : VK_IMAGE_LAYOUT_GENERAL;
1500                         VkImageViewType srViewType = modeIdx == ATTACHMENT_MODE_2DARRAY ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
1501                         VkImageTiling srTiling = (modeIdx == ATTACHMENT_MODE_TILING_LINEAR) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
1502
1503                         VkFormatProperties srFormatProperties;
1504                         m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), srFormat, &srFormatProperties);
1505                         VkFormatFeatureFlags srFormatFeatures = srTiling == VK_IMAGE_TILING_LINEAR ? srFormatProperties.linearTilingFeatures : srFormatProperties.optimalTilingFeatures;
1506
1507                         if (m_context.getFragmentShadingRateFeatures().attachmentFragmentShadingRate &&
1508                                 !(srFormatFeatures & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR))
1509                         {
1510                                 if (srFormat == VK_FORMAT_R8_UINT && srTiling == VK_IMAGE_TILING_OPTIMAL)
1511                                 {
1512                                         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;
1513                                         res = QP_TEST_RESULT_FAIL;
1514                                 }
1515                                 continue;
1516                         }
1517
1518                         Move<vk::VkDescriptorPool>                                      descriptorPool;
1519                         std::vector<Move<vk::VkDescriptorSet>>          descriptorSets;
1520                         VkDescriptorPoolCreateFlags                                     poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
1521
1522                         vk::DescriptorPoolBuilder poolBuilder;
1523                         for (deInt32 i = 0; i < (deInt32)(sizeof(bindings)/sizeof(bindings[0])); ++i)
1524                                 poolBuilder.addType(bindings[i].descriptorType, bindings[i].descriptorCount);
1525                         if (m_data.meshShader)
1526                                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
1527
1528                         descriptorPool = poolBuilder.build(vk, device, poolCreateFlags, static_cast<uint32_t>(descriptorSetLayouts.size()));
1529                         for (const auto& setLayout : descriptorSetLayouts)
1530                                 descriptorSets.push_back(makeDescriptorSet(vk, device, *descriptorPool, *setLayout));
1531
1532                         const auto mainDescriptorSet = descriptorSets.front().get();
1533
1534                         de::MovePtr<ImageWithMemory> srImage;
1535                         Move<VkImageView> srImageView;
1536                         VkImageUsageFlags srUsage = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR |
1537                                                                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT |
1538                                                                                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1539
1540                         if (m_data.useAttachment())
1541                         {
1542                                 const VkImageCreateInfo                 imageCreateInfo                 =
1543                                 {
1544                                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType                      sType;
1545                                         DE_NULL,                                                                // const void*                          pNext;
1546                                         (VkImageCreateFlags)0u,                                 // VkImageCreateFlags           flags;
1547                                         VK_IMAGE_TYPE_2D,                                               // VkImageType                          imageType;
1548                                         srFormat,                                                               // VkFormat                                     format;
1549                                         {
1550                                                 srWidth,                                                        // deUint32     width;
1551                                                 srHeight,                                                       // deUint32     height;
1552                                                 1u                                                                      // deUint32     depth;
1553                                         },                                                                              // VkExtent3D                           extent;
1554                                         1u,                                                                             // deUint32                                     mipLevels;
1555                                         numSRLayers,                                                    // deUint32                                     arrayLayers;
1556                                         VK_SAMPLE_COUNT_1_BIT,                                  // VkSampleCountFlagBits        samples;
1557                                         srTiling,                                                               // VkImageTiling                        tiling;
1558                                         srUsage,                                                                // VkImageUsageFlags            usage;
1559                                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                        sharingMode;
1560                                         0u,                                                                             // deUint32                                     queueFamilyIndexCount;
1561                                         DE_NULL,                                                                // const deUint32*                      pQueueFamilyIndices;
1562                                         VK_IMAGE_LAYOUT_UNDEFINED                               // VkImageLayout                        initialLayout;
1563                                 };
1564                                 srImage = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1565                                         vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1566
1567                                 VkImageViewCreateInfo           imageViewCreateInfo             =
1568                                 {
1569                                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                      sType;
1570                                         DE_NULL,                                                                        // const void*                          pNext;
1571                                         (VkImageViewCreateFlags)0u,                                     // VkImageViewCreateFlags       flags;
1572                                         **srImage,                                                                      // VkImage                                      image;
1573                                         srViewType,                                                                     // VkImageViewType                      viewType;
1574                                         srFormat,                                                                       // VkFormat                                     format;
1575                                         {
1576                                                 VK_COMPONENT_SWIZZLE_R,                                 // VkComponentSwizzle   r;
1577                                                 VK_COMPONENT_SWIZZLE_G,                                 // VkComponentSwizzle   g;
1578                                                 VK_COMPONENT_SWIZZLE_B,                                 // VkComponentSwizzle   b;
1579                                                 VK_COMPONENT_SWIZZLE_A                                  // VkComponentSwizzle   a;
1580                                         },                                                                                      // VkComponentMapping            components;
1581                                         {
1582                                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask;
1583                                                 0u,                                                                             // deUint32                             baseMipLevel;
1584                                                 1u,                                                                             // deUint32                             levelCount;
1585                                                 0u,                                                                             // deUint32                             baseArrayLayer;
1586                                                 srViewType == VK_IMAGE_VIEW_TYPE_2D ?
1587                                                 1 : numSRLayers,                                                // deUint32                             layerCount;
1588                                         }                                                                                       // VkImageSubresourceRange      subresourceRange;
1589                                 };
1590                                 srImageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1591                         }
1592
1593                         VkDescriptorImageInfo imageInfo;
1594                         VkDescriptorBufferInfo bufferInfo;
1595
1596                         VkWriteDescriptorSet w =
1597                         {
1598                                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                                                 // sType
1599                                 DE_NULL,                                                                                                                // pNext
1600                                 descriptorSets.front().get(),                                                                   // dstSet
1601                                 (deUint32)0,                                                                                                    // dstBinding
1602                                 0,                                                                                                                              // dstArrayElement
1603                                 1u,                                                                                                                             // descriptorCount
1604                                 bindings[0].descriptorType,                                                                             // descriptorType
1605                                 &imageInfo,                                                                                                             // pImageInfo
1606                                 &bufferInfo,                                                                                                    // pBufferInfo
1607                                 DE_NULL,                                                                                                                // pTexelBufferView
1608                         };
1609
1610                         abuf[0] = 0;
1611                         flushAlloc(vk, device, atomicBuffer->getAllocation());
1612
1613                         bufferInfo = makeDescriptorBufferInfo(**atomicBuffer, 0, atomicBufferSize);
1614                         w.dstBinding = 0;
1615                         w.descriptorType = bindings[0].descriptorType;
1616                         vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1617
1618                         imageInfo = makeDescriptorImageInfo(DE_NULL, *cbImageView, VK_IMAGE_LAYOUT_GENERAL);
1619                         w.dstBinding = 1;
1620                         w.descriptorType = bindings[1].descriptorType;
1621                         vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1622
1623                         bufferInfo = makeDescriptorBufferInfo(**colorOutputBuffer, 0, colorOutputBufferSize);
1624                         w.dstBinding = 2;
1625                         w.descriptorType = bindings[2].descriptorType;
1626                         vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1627
1628                         imageInfo = makeDescriptorImageInfo(*sampler, *derivImageView, VK_IMAGE_LAYOUT_GENERAL);
1629                         w.dstBinding = 3;
1630                         w.descriptorType = bindings[3].descriptorType;
1631                         vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1632
1633                         if (m_data.useDepthStencil)
1634                         {
1635                                 bufferInfo = makeDescriptorBufferInfo(**depthOutputBuffer, 0, depthOutputBufferSize);
1636                                 w.dstBinding = 4;
1637                                 w.descriptorType = bindings[4].descriptorType;
1638                                 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1639
1640                                 bufferInfo = makeDescriptorBufferInfo(**stencilOutputBuffer, 0, stencilOutputBufferSize);
1641                                 w.dstBinding = 5;
1642                                 w.descriptorType = bindings[5].descriptorType;
1643                                 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1644
1645                                 imageInfo = makeDescriptorImageInfo(DE_NULL, *dImageView, VK_IMAGE_LAYOUT_GENERAL);
1646                                 w.dstBinding = 6;
1647                                 w.descriptorType = bindings[6].descriptorType;
1648                                 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1649
1650                                 imageInfo = makeDescriptorImageInfo(DE_NULL, *sImageView, VK_IMAGE_LAYOUT_GENERAL);
1651                                 w.dstBinding = 7;
1652                                 w.descriptorType = bindings[7].descriptorType;
1653                                 vk.updateDescriptorSets(device, 1, &w, 0, NULL);
1654                         }
1655
1656                         // Update vertex buffer descriptor.
1657                         if (m_data.meshShader)
1658                         {
1659                                 const auto                                      extraBufferInfo = makeDescriptorBufferInfo(vertexBuffer->get(), 0ull, vertexBufferSize);
1660                                 const VkWriteDescriptorSet      extraWrite              =
1661                                 {
1662                                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                                                 // sType
1663                                         DE_NULL,                                                                                                                // pNext
1664                                         descriptorSets.back().get(),                                                                    // dstSet
1665                                         (deUint32)0,                                                                                                    // dstBinding
1666                                         0,                                                                                                                              // dstArrayElement
1667                                         1u,                                                                                                                             // descriptorCount
1668                                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,                                                              // descriptorType
1669                                         nullptr,                                                                                                                // pImageInfo
1670                                         &extraBufferInfo,                                                                                               // pBufferInfo
1671                                         DE_NULL,                                                                                                                // pTexelBufferView
1672                                 };
1673
1674                                 vk.updateDescriptorSets(device, 1u, &extraWrite, 0u, nullptr);
1675                         }
1676
1677                         Move<VkRenderPass> renderPass;
1678                         Move<VkFramebuffer> framebuffer;
1679
1680                         std::vector<VkImageView> attachments;
1681                         attachments.push_back(*cbImageView);
1682                         deUint32 dsAttachmentIdx = 0, srAttachmentIdx = 0;
1683                         if (m_data.useAttachment())
1684                         {
1685                                 srAttachmentIdx = (deUint32)attachments.size();
1686                                 attachments.push_back(*srImageView);
1687                         }
1688                         if (m_data.useDepthStencil)
1689                         {
1690                                 dsAttachmentIdx = (deUint32)attachments.size();
1691                                 attachments.push_back(*dsImageView);
1692                         }
1693
1694                         if (!m_data.groupParams->useDynamicRendering)
1695                         {
1696                                 const vk::VkAttachmentReference2 colorAttachmentReference
1697                                 {
1698                                         VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,                                       // sType
1699                                         DE_NULL,                                                                                                        // pNext
1700                                         0,                                                                                                                      // attachment
1701                                         vk::VK_IMAGE_LAYOUT_GENERAL,                                                            // layout
1702                                         0,                                                                                                                      // aspectMask
1703                                 };
1704
1705                                 const vk::VkAttachmentReference2 fragmentShadingRateAttachment =
1706                                 {
1707                                         VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,                                       // sType
1708                                         DE_NULL,                                                                                                        // pNext
1709                                         srAttachmentIdx,                                                                                        // attachment
1710                                         srLayout,                                                                                                       // layout
1711                                         0,                                                                                                                      // aspectMask
1712                                 };
1713
1714                                 const vk::VkAttachmentReference2 depthAttachmentReference =
1715                                 {
1716                                         VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,                                       // sType
1717                                         DE_NULL,                                                                                                        // pNext
1718                                         dsAttachmentIdx,                                                                                        // attachment
1719                                         vk::VK_IMAGE_LAYOUT_GENERAL,                                                            // layout
1720                                         0,                                                                                                                      // aspectMask
1721                                 };
1722
1723                                 const bool                                                                              noAttachmentPtr                         = (m_data.attachmentUsage == AttachmentUsage::NO_ATTACHMENT_PTR);
1724                                 const VkFragmentShadingRateAttachmentInfoKHR    shadingRateAttachmentInfo       =
1725                                 {
1726                                         VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,                                                    // VkStructureType                                sType;
1727                                         DE_NULL,                                                                                                                                                                // const void*                                    pNext;
1728                                         (noAttachmentPtr ? nullptr : &fragmentShadingRateAttachment),                                                   // const VkAttachmentReference2*        pFragmentShadingRateAttachment;
1729                                         { srTexelWidth, srTexelHeight },                                                                                                                // VkExtent2D                                      shadingRateAttachmentTexelSize;
1730                                 };
1731
1732                                 const bool                                              useAttachmentInfo       = (m_data.attachmentUsage != AttachmentUsage::NO_ATTACHMENT);
1733                                 const VkSubpassDescription2             subpassDesc                     =
1734                                 {
1735                                         VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,                                                // sType
1736                                         (useAttachmentInfo ? &shadingRateAttachmentInfo : nullptr),             // pNext;
1737                                         (vk::VkSubpassDescriptionFlags)0,                                                               // flags
1738                                         vk::VK_PIPELINE_BIND_POINT_GRAPHICS,                                                    // pipelineBindPoint
1739                                         m_data.multiView ? 0x3 : 0u,                                                                    // viewMask
1740                                         0u,                                                                                                                             // inputCount
1741                                         DE_NULL,                                                                                                                // pInputAttachments
1742                                         1,                                                                                                                              // colorCount
1743                                         &colorAttachmentReference,                                                                              // pColorAttachments
1744                                         DE_NULL,                                                                                                                // pResolveAttachments
1745                                         m_data.useDepthStencil ? &depthAttachmentReference : DE_NULL,   // depthStencilAttachment
1746                                         0u,                                                                                                                             // preserveCount
1747                                         DE_NULL,                                                                                                                // pPreserveAttachments
1748                                 };
1749
1750                                 std::vector<VkAttachmentDescription2> attachmentDescriptions
1751                                 {
1752                                         {
1753                                                 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,     // VkStructureType sType;
1754                                                 DE_NULL,                                                                        // const void* pNext;
1755                                                 (VkAttachmentDescriptionFlags)0u,                       // VkAttachmentDescriptionFlags         flags;
1756                                                 cbFormat,                                       // VkFormat                                                     format;
1757                                                 m_data.samples,                                                         // VkSampleCountFlagBits                        samples;
1758                                                 VK_ATTACHMENT_LOAD_OP_LOAD,                                     // VkAttachmentLoadOp                           loadOp;
1759                                                 VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                          storeOp;
1760                                                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                        // VkAttachmentLoadOp                           stencilLoadOp;
1761                                                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                       // VkAttachmentStoreOp                          stencilStoreOp;
1762                                                 VK_IMAGE_LAYOUT_GENERAL,                                        // VkImageLayout                                        initialLayout;
1763                                                 VK_IMAGE_LAYOUT_GENERAL                                         // VkImageLayout                                        finalLayout;
1764                                         }
1765                                 };
1766                                 if (m_data.useAttachment())
1767                                         attachmentDescriptions.push_back(
1768                                         {
1769                                                 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,     // VkStructureType sType;
1770                                                 DE_NULL,                                                                        // const void* pNext;
1771                                                 (VkAttachmentDescriptionFlags)0u,                       // VkAttachmentDescriptionFlags         flags;
1772                                                 srFormat,                                                                       // VkFormat                                                     format;
1773                                                 VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits                        samples;
1774                                                 VK_ATTACHMENT_LOAD_OP_LOAD,                                     // VkAttachmentLoadOp                           loadOp;
1775                                                 VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                          storeOp;
1776                                                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                        // VkAttachmentLoadOp                           stencilLoadOp;
1777                                                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                       // VkAttachmentStoreOp                          stencilStoreOp;
1778                                                 srLayout,                                                                       // VkImageLayout                                        initialLayout;
1779                                                 srLayout                                                                        // VkImageLayout                                        finalLayout;
1780                                         }
1781                                         );
1782
1783                                 if (m_data.useDepthStencil)
1784                                         attachmentDescriptions.push_back(
1785                                         {
1786                                                 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,     // VkStructureType sType;
1787                                                 DE_NULL,                                                                        // const void* pNext;
1788                                                 (VkAttachmentDescriptionFlags)0u,                       // VkAttachmentDescriptionFlags         flags;
1789                                                 dsFormat,                                                                       // VkFormat                                                     format;
1790                                                 m_data.samples,                                                         // VkSampleCountFlagBits                        samples;
1791                                                 VK_ATTACHMENT_LOAD_OP_LOAD,                                     // VkAttachmentLoadOp                           loadOp;
1792                                                 VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                          storeOp;
1793                                                 VK_ATTACHMENT_LOAD_OP_LOAD,                                     // VkAttachmentLoadOp                           stencilLoadOp;
1794                                                 VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                          stencilStoreOp;
1795                                                 VK_IMAGE_LAYOUT_GENERAL,                                        // VkImageLayout                                        initialLayout;
1796                                                 VK_IMAGE_LAYOUT_GENERAL                                         // VkImageLayout                                        finalLayout;
1797                                         }
1798                                         );
1799
1800                                 const deUint32                                  correlatedViewMask = 0x3;
1801                                 const VkRenderPassCreateInfo2   renderPassParams        =
1802                                 {
1803                                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,                    // sType
1804                                         DE_NULL,                                                                                                // pNext
1805                                         (vk::VkRenderPassCreateFlags)0,
1806                                         (deUint32)attachmentDescriptions.size(),                                // attachmentCount
1807                                         &attachmentDescriptions[0],                                                             // pAttachments
1808                                         1u,                                                                                                             // subpassCount
1809                                         &subpassDesc,                                                                                   // pSubpasses
1810                                         0u,                                                                                                             // dependencyCount
1811                                         DE_NULL,                                                                                                // pDependencies
1812                                         m_data.correlationMask,                                                                 // correlatedViewMaskCount
1813                                         m_data.correlationMask ? &correlatedViewMask : DE_NULL  // pCorrelatedViewMasks
1814                                 };
1815
1816                                 renderPass = createRenderPass2(vk, device, &renderPassParams);
1817
1818                                 std::vector<VkFramebufferAttachmentImageInfo> framebufferAttachmentImageInfo;
1819                                 framebufferAttachmentImageInfo.push_back(
1820                                         {
1821                                                 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,            //  VkStructureType             sType;
1822                                                 DE_NULL,                                                                                                        //  const void*                 pNext;
1823                                                 (VkImageCreateFlags)0u,                                                                         //  VkImageCreateFlags  flags;
1824                                                 cbUsage,                                                                                                        //  VkImageUsageFlags   usage;
1825                                                 m_data.framebufferDim.width,                                                            //  deUint32                    width;
1826                                                 m_data.framebufferDim.height,                                                           //  deUint32                    height;
1827                                                 m_data.numColorLayers,                                                                          //  deUint32                    layerCount;
1828                                                 1u,                                                                                                                     //  deUint32                    viewFormatCount;
1829                                                 &cbFormat                                                                                                       //  const VkFormat*             pViewFormats;
1830                                         }
1831                                 );
1832                                 if (m_data.useAttachment())
1833                                         framebufferAttachmentImageInfo.push_back(
1834                                         {
1835                                                 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,            //  VkStructureType             sType;
1836                                                 DE_NULL,                                                                                                        //  const void*                 pNext;
1837                                                 (VkImageCreateFlags)0u,                                                                         //  VkImageCreateFlags  flags;
1838                                                 srUsage,                                                                                                        //  VkImageUsageFlags   usage;
1839                                                 srWidth,                                                                                                        //  deUint32                    width;
1840                                                 srHeight,                                                                                                       //  deUint32                    height;
1841                                                 numSRLayers,                                                                                            //  deUint32                    layerCount;
1842                                                 1u,                                                                                                                     //  deUint32                    viewFormatCount;
1843                                                 &srFormat                                                                                                       //  const VkFormat*             pViewFormats;
1844                                         }
1845                                         );
1846
1847                                 if (m_data.useDepthStencil)
1848                                         framebufferAttachmentImageInfo.push_back(
1849                                         {
1850                                                 VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,            //  VkStructureType             sType;
1851                                                 DE_NULL,                                                                                                        //  const void*                 pNext;
1852                                                 (VkImageCreateFlags)0u,                                                                         //  VkImageCreateFlags  flags;
1853                                                 dsUsage,                                                                                                        //  VkImageUsageFlags   usage;
1854                                                 m_data.framebufferDim.width,                                                            //  deUint32                    width;
1855                                                 m_data.framebufferDim.height,                                                           //  deUint32                    height;
1856                                                 m_data.numColorLayers,                                                                          //  deUint32                    layerCount;
1857                                                 1u,                                                                                                                     //  deUint32                    viewFormatCount;
1858                                                 &dsFormat                                                                                                       //  const VkFormat*             pViewFormats;
1859                                         }
1860                                         );
1861
1862                                 const VkFramebufferAttachmentsCreateInfo                                framebufferAttachmentsCreateInfo        =
1863                                 {
1864                                         VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,          //  VkStructureType                                                             sType;
1865                                         DE_NULL,                                                                                                        //  const void*                                                                 pNext;
1866                                         (deUint32)framebufferAttachmentImageInfo.size(),                        //  deUint32                                                                    attachmentImageInfoCount;
1867                                         &framebufferAttachmentImageInfo[0]                                                      //  const VkFramebufferAttachmentImageInfo*             pAttachmentImageInfos;
1868                                 };
1869
1870                                 const vk::VkFramebufferCreateInfo       framebufferParams       =
1871                                 {
1872                                         vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,  // sType
1873                                         imagelessFB ? &framebufferAttachmentsCreateInfo : DE_NULL,                              // pNext
1874                                         (vk::VkFramebufferCreateFlags)(imagelessFB ? VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT : 0),
1875                                         *renderPass,                                                                    // renderPass
1876                                         (deUint32)attachments.size(),                                   // attachmentCount
1877                                         imagelessFB ? DE_NULL : &attachments[0],                // pAttachments
1878                                         m_data.framebufferDim.width,                                    // width
1879                                         m_data.framebufferDim.height,                                   // height
1880                                         m_data.multiView ? 1 : m_data.numColorLayers,   // layers
1881                                 };
1882
1883                                 framebuffer = createFramebuffer(vk, device, &framebufferParams);
1884                         }
1885
1886                         const VkVertexInputBindingDescription           vertexBinding =
1887                         {
1888                                 0u,                                                     // deUint32                             binding;
1889                                 sizeof(float) * 2,                      // deUint32                             stride;
1890                                 VK_VERTEX_INPUT_RATE_VERTEX     // VkVertexInputRate    inputRate;
1891                         };
1892                         const VkVertexInputAttributeDescription         vertexInputAttributeDescription =
1893                         {
1894                                 0u,                                                     // deUint32     location;
1895                                 0u,                                                     // deUint32     binding;
1896                                 VK_FORMAT_R32G32_SFLOAT,        // VkFormat     format;
1897                                 0u                                                      // deUint32     offset;
1898                         };
1899
1900                         const VkPipelineVertexInputStateCreateInfo              vertexInputStateCreateInfo              =
1901                         {
1902                                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      // VkStructureType                                                      sType;
1903                                 DE_NULL,                                                                                                        // const void*                                                          pNext;
1904                                 (VkPipelineVertexInputStateCreateFlags)0,                                       // VkPipelineVertexInputStateCreateFlags        flags;
1905                                 1u,                                                                                                                     // deUint32                                                                     vertexBindingDescriptionCount;
1906                                 &vertexBinding,                                                                                         // const VkVertexInputBindingDescription*       pVertexBindingDescriptions;
1907                                 1u,                                                                                                                     // deUint32                                                                     vertexAttributeDescriptionCount;
1908                                 &vertexInputAttributeDescription                                                        // const VkVertexInputAttributeDescription*     pVertexAttributeDescriptions;
1909                         };
1910
1911                         const VkPipelineRasterizationConservativeStateCreateInfoEXT consRastState =
1912                         {
1913                                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,    // VkStructureType                                                                                 sType;
1914                                 DE_NULL,                                                                                                                                                // const void*                                                                                     pNext;
1915                                 (VkPipelineRasterizationConservativeStateCreateFlagsEXT)0,                                              // VkPipelineRasterizationConservativeStateCreateFlagsEXT       flags;
1916                                 m_data.conservativeMode,                                                                                                                // VkConservativeRasterizationModeEXT                                           conservativeRasterizationMode;
1917                                 0.0f,                                                                                                                                                   // float                                                                                                         extraPrimitiveOverestimationSize;
1918                         };
1919
1920                         const VkPipelineRasterizationStateCreateInfo    rasterizationStateCreateInfo    =
1921                         {
1922                                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,             // VkStructureType                                                      sType;
1923                                 m_data.conservativeEnable ? &consRastState : DE_NULL,                   // const void*                                                          pNext;
1924                                 (VkPipelineRasterizationStateCreateFlags)0,                                             // VkPipelineRasterizationStateCreateFlags      flags;
1925                                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthClampEnable;
1926                                 VK_FALSE,                                                                                                               // VkBool32                                                                     rasterizerDiscardEnable;
1927                                 VK_POLYGON_MODE_FILL,                                                                                   // VkPolygonMode                                                        polygonMode;
1928                                 VK_CULL_MODE_NONE,                                                                                              // VkCullModeFlags                                                      cullMode;
1929                                 VK_FRONT_FACE_CLOCKWISE,                                                                                // VkFrontFace                                                          frontFace;
1930                                 VK_FALSE,                                                                                                               // VkBool32                                                                     depthBiasEnable;
1931                                 0.0f,                                                                                                                   // float                                                                        depthBiasConstantFactor;
1932                                 0.0f,                                                                                                                   // float                                                                        depthBiasClamp;
1933                                 0.0f,                                                                                                                   // float                                                                        depthBiasSlopeFactor;
1934                                 1.0f                                                                                                                    // float                                                                        lineWidth;
1935                         };
1936
1937                         // Kill some bits from each AA mode
1938                         const VkSampleMask      sampleMask      = m_data.sampleMaskTest ? 0x9 : 0x7D56;
1939                         const VkSampleMask*     pSampleMask = m_data.useApiSampleMask ? &sampleMask : DE_NULL;
1940
1941                         // All samples at pixel center. We'll validate that pixels are fully covered or uncovered.
1942                         std::vector<VkSampleLocationEXT> sampleLocations(m_data.samples, { 0.5f, 0.5f });
1943                         const VkSampleLocationsInfoEXT sampleLocationsInfo =
1944                         {
1945                                 VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,    // VkStructureType                              sType;
1946                                 DE_NULL,                                                                                // const void*                                  pNext;
1947                                 (VkSampleCountFlagBits)m_data.samples,                  // VkSampleCountFlagBits                sampleLocationsPerPixel;
1948                                 { 1, 1 },                                                                               // VkExtent2D                                   sampleLocationGridSize;
1949                                 (deUint32)m_data.samples,                                               // uint32_t                                             sampleLocationsCount;
1950                                 &sampleLocations[0],                                                    // const VkSampleLocationEXT*   pSampleLocations;
1951                         };
1952
1953                         const VkPipelineSampleLocationsStateCreateInfoEXT pipelineSampleLocationsCreateInfo =
1954                         {
1955                                 VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,      // VkStructureType                      sType;
1956                                 DE_NULL,                                                                                                                        // const void*                          pNext;
1957                                 VK_TRUE,                                                                                                                        // VkBool32                                     sampleLocationsEnable;
1958                                 sampleLocationsInfo,                                                                                            // VkSampleLocationsInfoEXT     sampleLocationsInfo;
1959                         };
1960
1961                         const VkPipelineMultisampleStateCreateInfo              multisampleStateCreateInfo =
1962                         {
1963                                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,       // VkStructureType                                                      sType
1964                                 m_data.sampleLocations ? &pipelineSampleLocationsCreateInfo : DE_NULL,  // const void*                                  pNext
1965                                 0u,                                                                                                                     // VkPipelineMultisampleStateCreateFlags        flags
1966                                 (VkSampleCountFlagBits)m_data.samples,                                          // VkSampleCountFlagBits                                        rasterizationSamples
1967                                 (VkBool32)m_data.sampleShadingEnable,                                           // VkBool32                                                                     sampleShadingEnable
1968                                 1.0f,                                                                                                           // float                                                                        minSampleShading
1969                                 pSampleMask,                                                                                            // const VkSampleMask*                                          pSampleMask
1970                                 VK_FALSE,                                                                                                       // VkBool32                                                                     alphaToCoverageEnable
1971                                 VK_FALSE                                                                                                        // VkBool32                                                                     alphaToOneEnable
1972                         };
1973
1974                         std::vector<VkViewport> viewports;
1975                         std::vector<VkRect2D> scissors;
1976                         if (m_data.multiViewport)
1977                         {
1978                                 // Split the viewport into left and right halves
1979                                 int x0 = 0, x1 = m_data.framebufferDim.width/2, x2 = m_data.framebufferDim.width;
1980
1981                                 viewports.push_back(makeViewport((float)x0, 0, std::max((float)(x1 - x0), 1.0f), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1982                                 scissors.push_back(makeRect2D(x0, 0, x1 - x0, m_data.framebufferDim.height));
1983
1984                                 viewports.push_back(makeViewport((float)x1, 0, std::max((float)(x2 - x1), 1.0f), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
1985                                 scissors.push_back(makeRect2D(x1, 0, x2 - x1, m_data.framebufferDim.height));
1986                         }
1987                         else
1988                         {
1989                                 viewports.push_back(makeViewport(m_data.framebufferDim.width, m_data.framebufferDim.height));
1990                                 scissors.push_back(makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height));
1991                         }
1992
1993                         const auto& binaries = m_context.getBinaryCollection();
1994                         Move<VkShaderModule> fragShader = createShaderModule(vk, device, binaries.get("frag"), 0);
1995                         Move<VkShaderModule> vertShader;
1996                         Move<VkShaderModule> geomShader;
1997                         Move<VkShaderModule> meshShader;
1998
1999                         if (m_data.meshShader)
2000                         {
2001                                 meshShader = createShaderModule(vk, device, binaries.get("mesh"), 0);
2002                         }
2003                         else
2004                         {
2005                                 vertShader = createShaderModule(vk, device, binaries.get("vert"), 0);
2006                                 if (m_data.geometryShader)
2007                                         geomShader = createShaderModule(vk, device, binaries.get("geom"), 0);
2008                         }
2009
2010                         const deUint32 fragSizeWH = m_data.sampleMaskTest ? 2 : 0;
2011
2012                         PipelineRenderingCreateInfoWrapper renderingCreateInfoWrapper;
2013 #ifndef CTS_USES_VULKANSC
2014                         VkPipelineRenderingCreateInfoKHR renderingCreateInfo
2015                         {
2016                                 VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
2017                                 DE_NULL,
2018                                 m_data.multiView ? 0x3 : 0u,
2019                                 1u,
2020                                 &cbFormat,
2021                                 dsFormat,
2022                                 dsFormat
2023                         };
2024                         renderingCreateInfoWrapper.ptr = m_data.groupParams->useDynamicRendering ? &renderingCreateInfo : DE_NULL;
2025 #endif // CTS_USES_VULKANSC
2026
2027                         VkPipelineFragmentShadingRateStateCreateInfoKHR shadingRateStateCreateInfo
2028                         {
2029                                 VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, // VkStructureType                                              sType;
2030                                 renderingCreateInfoWrapper.ptr,                                                                                 // const void*                                                  pNext;
2031                                 { fragSizeWH, fragSizeWH },                                                                                             // VkExtent2D                                                   fragmentSize;
2032                                 { m_data.combinerOp[0], m_data.combinerOp[1] },                                                 // VkFragmentShadingRateCombinerOpKHR   combinerOps[2];
2033                         };
2034
2035                         VkDynamicState dynamicState = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR;
2036                         const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo
2037                         {
2038                                 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,           // VkStructureType                                              sType;
2039                                 DE_NULL,                                                                                                        // const void*                                                  pNext;
2040                                 (VkPipelineDynamicStateCreateFlags)0,                                           // VkPipelineDynamicStateCreateFlags    flags;
2041                                 m_data.useDynamicState ? 1u : 0u,                                                       // uint32_t                                                             dynamicStateCount;
2042                                 &dynamicState,                                                                                          // const VkDynamicState*                                pDynamicStates;
2043                         };
2044
2045                         // Enable depth/stencil writes, always passing
2046                         VkPipelineDepthStencilStateCreateInfo           depthStencilStateParams
2047                         {
2048                                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,     // VkStructureType                                                      sType;
2049                                 DE_NULL,                                                                                                        // const void*                                                          pNext;
2050                                 0u,                                                                                                                     // VkPipelineDepthStencilStateCreateFlags       flags;
2051                                 VK_TRUE,                                                                                                        // VkBool32                                                                     depthTestEnable;
2052                                 VK_TRUE,                                                                                                        // VkBool32                                                                     depthWriteEnable;
2053                                 VK_COMPARE_OP_ALWAYS,                                                                           // VkCompareOp                                                          depthCompareOp;
2054                                 VK_FALSE,                                                                                                       // VkBool32                                                                     depthBoundsTestEnable;
2055                                 VK_TRUE,                                                                                                        // VkBool32                                                                     stencilTestEnable;
2056                                 // VkStencilOpState     front;
2057                                 {
2058                                         VK_STENCIL_OP_REPLACE,  // VkStencilOp  failOp;
2059                                         VK_STENCIL_OP_REPLACE,  // VkStencilOp  passOp;
2060                                         VK_STENCIL_OP_REPLACE,  // VkStencilOp  depthFailOp;
2061                                         VK_COMPARE_OP_ALWAYS,   // VkCompareOp  compareOp;
2062                                         0u,                                             // deUint32             compareMask;
2063                                         0xFFu,                                  // deUint32             writeMask;
2064                                         0xFFu,                                  // deUint32             reference;
2065                                 },
2066                                 // VkStencilOpState     back;
2067                                 {
2068                                         VK_STENCIL_OP_REPLACE,  // VkStencilOp  failOp;
2069                                         VK_STENCIL_OP_REPLACE,  // VkStencilOp  passOp;
2070                                         VK_STENCIL_OP_REPLACE,  // VkStencilOp  depthFailOp;
2071                                         VK_COMPARE_OP_ALWAYS,   // VkCompareOp  compareOp;
2072                                         0u,                                             // deUint32             compareMask;
2073                                         0xFFu,                                  // deUint32             writeMask;
2074                                         0xFFu,                                  // deUint32             reference;
2075                                 },
2076                                 0.0f,                                           // float                        minDepthBounds;
2077                                 0.0f,                                           // float                        maxDepthBounds;
2078                         };
2079
2080                         const VkQueue                           queue                           = m_context.getUniversalQueue();
2081                         Move<VkCommandPool>                     cmdPool                         = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, m_context.getUniversalQueueFamilyIndex());
2082                         Move<VkCommandBuffer>           cmdBuffer                       = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
2083                         Move<VkCommandBuffer>           secCmdBuffer;
2084                         VkClearValue                            clearColor                      = makeClearValueColorU32(0, 0, 0, 0);
2085                         VkClearValue                            clearDepthStencil       = makeClearValueDepthStencil(0.0, 0);
2086
2087                         std::vector<GraphicsPipelineWrapper> pipelines;
2088                         pipelines.reserve(m_data.useDynamicState ? 1u : NUM_TRIANGLES);
2089
2090                         std::vector<VkDescriptorSet> descriptorSetsRaw;
2091
2092                         descriptorSetsRaw.reserve(descriptorSets.size());
2093
2094                         std::transform(begin(descriptorSets), end(descriptorSets), std::back_inserter(descriptorSetsRaw),
2095                                 [](const Move<VkDescriptorSet>& elem) { return elem.get(); });
2096
2097 #ifndef CTS_USES_VULKANSC
2098                         const VkExtent2D srTexelSize { srTexelWidth, srTexelHeight };
2099                         if (m_data.groupParams->useSecondaryCmdBuffer)
2100                         {
2101                                 secCmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
2102
2103                                 // record secondary command buffer
2104                                 if (m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
2105                                 {
2106                                         beginSecondaryCmdBuffer(*secCmdBuffer, cbFormat, dsFormat, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT);
2107                                         beginDynamicRender(*secCmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView,
2108                                                                            clearColor, clearDepthStencil);
2109                                 }
2110                                 else
2111                                         beginSecondaryCmdBuffer(*secCmdBuffer, cbFormat, dsFormat);
2112
2113                                 drawCommands(*secCmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
2114                                                          &vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
2115                                                          &depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
2116                                                          renderingCreateInfoWrapper, *vertShader, *geomShader, *meshShader, *fragShader, descriptorSetsRaw, **vertexBuffer, pushConstantSize);
2117
2118                                 if (m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
2119                                         endRendering(vk, *secCmdBuffer);
2120
2121                                 endCommandBuffer(vk, *secCmdBuffer);
2122
2123                                 // record primary command buffer
2124                                 beginCommandBuffer(vk, *cmdBuffer, 0u);
2125
2126                                 preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
2127                                                                   srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
2128                                 if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
2129                                         beginDynamicRender(*cmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView,
2130                                                                            clearColor, clearDepthStencil, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR);
2131
2132                                 vk.cmdExecuteCommands(*cmdBuffer, 1u, &*secCmdBuffer);
2133
2134                                 if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
2135                                         endRendering(vk, *cmdBuffer);
2136                         }
2137                         else if (m_data.groupParams->useDynamicRendering)
2138                         {
2139                                 beginCommandBuffer(vk, *cmdBuffer);
2140                                 preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
2141                                                                   srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
2142                                 beginDynamicRender(*cmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView, clearColor, clearDepthStencil);
2143                                 drawCommands(*cmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
2144                                                          &vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
2145                                                          &depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
2146                                                          renderingCreateInfoWrapper, *vertShader, *geomShader, *meshShader, *fragShader, descriptorSetsRaw, **vertexBuffer, pushConstantSize);
2147                                 endRendering(vk, *cmdBuffer);
2148                         }
2149 #endif // CTS_USES_VULKANSC
2150
2151                         if (!m_data.groupParams->useDynamicRendering)
2152                         {
2153                                 beginCommandBuffer(vk, *cmdBuffer);
2154                                 preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
2155                                                                   srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
2156                                 beginLegacyRender(*cmdBuffer, *renderPass, *framebuffer, *srImageView, *cbImageView, *dsImageView, imagelessFB);
2157                                 drawCommands(*cmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
2158                                                          &vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
2159                                                          &depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
2160                                                          renderingCreateInfoWrapper, *vertShader, *geomShader, *meshShader, *fragShader, descriptorSetsRaw, **vertexBuffer, pushConstantSize);
2161                                 endRenderPass(vk, *cmdBuffer);
2162                         }
2163
2164                         VkMemoryBarrier memBarrier
2165                         {
2166                                 VK_STRUCTURE_TYPE_MEMORY_BARRIER,
2167                                 DE_NULL,
2168                                 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
2169                                 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT
2170                         };
2171                         vk.cmdPipelineBarrier(*cmdBuffer, allPipelineStages, allPipelineStages, 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2172
2173                         vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1, &mainDescriptorSet, 0u, DE_NULL);
2174                         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline);
2175
2176                         // Copy color/depth/stencil buffers to buffer memory
2177                         vk.cmdDispatch(*cmdBuffer, m_data.framebufferDim.width, m_data.framebufferDim.height, m_data.numColorLayers);
2178
2179                         memBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
2180                         memBarrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
2181                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
2182                                 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2183
2184                         endCommandBuffer(vk, *cmdBuffer);
2185
2186                         submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
2187
2188                         deUint32 *colorptr = (deUint32 *)colorOutputBuffer->getAllocation().getHostPtr();
2189                         invalidateAlloc(vk, device, colorOutputBuffer->getAllocation());
2190
2191                         invalidateAlloc(vk, device, atomicBuffer->getAllocation());
2192
2193                         float *depthptr = DE_NULL;
2194                         deUint32 *stencilptr = DE_NULL;
2195
2196                         if (m_data.useDepthStencil)
2197                         {
2198                                 depthptr = (float *)depthOutputBuffer->getAllocation().getHostPtr();
2199                                 invalidateAlloc(vk, device, depthOutputBuffer->getAllocation());
2200
2201                                 stencilptr = (deUint32 *)stencilOutputBuffer->getAllocation().getHostPtr();
2202                                 invalidateAlloc(vk, device, stencilOutputBuffer->getAllocation());
2203                         }
2204
2205                         // Loop over all samples and validate the output
2206                         for (deUint32 layer = 0; layer < m_data.numColorLayers && res == QP_TEST_RESULT_PASS; ++layer)
2207                         {
2208                                 for (deUint32 y = 0; y < m_data.framebufferDim.height && res == QP_TEST_RESULT_PASS; ++y)
2209                                 {
2210                                         for (deUint32 x = 0; x < m_data.framebufferDim.width && res == QP_TEST_RESULT_PASS; ++x)
2211                                         {
2212                                                 for (deInt32 s = 0; s < m_data.samples && res == QP_TEST_RESULT_PASS; ++s)
2213                                                 {
2214                                                         deUint32 *sample = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2215
2216                                                         // If testing the rasterizer sample mask, if this sample is not set in the
2217                                                         // mask then it shouldn't have written anything.
2218                                                         if (m_data.useApiSampleMask && !(sampleMask & (1 << s)) && sample[2] != 0)
2219                                                         {
2220                                                                 log << tcu::TestLog::Message << std::hex << "sample written despite pSampleMask (" << x << "," << y << ",sample " << s << ")" << tcu::TestLog::EndMessage;
2221                                                                 res = QP_TEST_RESULT_FAIL;
2222                                                                 continue;
2223                                                         }
2224
2225                                                         // The same isn't covered by any primitives, skip it
2226                                                         if (sample[2] == 0)
2227                                                                 continue;
2228
2229                                                         // skip samples that have the same value as sample zero - it would be redundant to check them.
2230                                                         if (s > 0)
2231                                                         {
2232                                                                 deUint32 *sample0 = &colorptr[4*(((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0)];
2233                                                                 bool same = deMemCmp(sample, sample0, 16) == 0;
2234
2235                                                                 if (m_data.fragDepth)
2236                                                                 {
2237                                                                         float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2238                                                                         float *dsample0 = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2239                                                                         same = same && (*dsample == *dsample0);
2240                                                                 }
2241
2242                                                                 if (m_data.fragStencil)
2243                                                                 {
2244                                                                         deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2245                                                                         deUint32 *ssample0 = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + 0];
2246                                                                         same = same && (*ssample == *ssample0);
2247                                                                 }
2248
2249                                                                 if (same)
2250                                                                         continue;
2251                                                         }
2252
2253                                                         // Fragment shader writes error codes to .w component.
2254                                                         // All nonzero values are unconditionally failures
2255                                                         if (sample[3] != 0)
2256                                                         {
2257                                                                 if (sample[3] == ERROR_FRAGCOORD_CENTER)
2258                                                                         log << tcu::TestLog::Message << std::hex << "fragcoord test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2259                                                                 else if (sample[3] == ERROR_VTG_READBACK)
2260                                                                         log << tcu::TestLog::Message << std::hex << "vs/gs output readback test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2261                                                                 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_DERIV)
2262                                                                         log << tcu::TestLog::Message << std::hex << "fragcoord derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2263                                                                                                                                                                 "(0x" << ((sample[3] >>  8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2264                                                                                                                                                                 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2265                                                                 else if ((sample[3] & 0xFF) == ERROR_FRAGCOORD_IMPLICIT_DERIV)
2266                                                                         log << tcu::TestLog::Message << std::hex << "implicit derivative test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")="
2267                                                                                                                                                                 "(0x" << ((sample[3] >>  8) & 0x3F) << ",0x" << ((sample[3] >> 14) & 0x3F) << "), expected="
2268                                                                                                                                                                 "(0x" << ((sample[3] >> 20) & 0x3F) << ",0x" << ((sample[3] >> 26) & 0x3F) << ")" << tcu::TestLog::EndMessage;
2269                                                                 else
2270                                                                         log << tcu::TestLog::Message << std::hex << "w coord unknown test failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")" << tcu::TestLog::EndMessage;
2271                                                                 res = QP_TEST_RESULT_FAIL;
2272                                                                 continue;
2273                                                         }
2274
2275                                                         // x component of sample
2276                                                         deUint32 rate = sample[0];
2277                                                         // fragment size
2278                                                         deUint32 pixelsX = 1 << ((rate/4)&3);
2279                                                         deUint32 pixelsY = 1 << (rate&3);
2280
2281                                                         // Fragment region
2282                                                         deUint32 fragMinX = x & ~(pixelsX-1);
2283                                                         deUint32 fragMinY = y & ~(pixelsY-1);
2284                                                         deUint32 fragMaxX = fragMinX + pixelsX;
2285                                                         deUint32 fragMaxY = fragMinY + pixelsY;
2286
2287                                                         // Clamp to FB dimension for odd sizes
2288                                                         if (fragMaxX > m_data.framebufferDim.width)
2289                                                                 fragMaxX = m_data.framebufferDim.width;
2290                                                         if (fragMaxY > m_data.framebufferDim.height)
2291                                                                 fragMaxY = m_data.framebufferDim.height;
2292
2293                                                         // z component of sample
2294                                                         deUint32 primID = sample[2] >> 24;
2295                                                         deUint32 atomVal = sample[2] & 0xFFFFFF;
2296
2297                                                         // Compute pipeline and primitive rate from primitive ID, and attachment
2298                                                         // rate from the x/y coordinate
2299                                                         deInt32 pipelineRate = PrimIDToPipelineShadingRate(primID);
2300                                                         deInt32 primitiveRate = m_data.shaderWritesRate ? PrimIDToPrimitiveShadingRate(primID) : 0;
2301
2302                                                         deInt32 attachmentLayer = (m_data.srLayered && modeIdx == ATTACHMENT_MODE_2DARRAY) ? layer : 0;
2303                                                         deInt32 attachmentRate = m_data.useAttachment() ? fillPtr[srFillBpp*((attachmentLayer * srHeight + (y / srTexelHeight)) * srWidth + (x / srTexelWidth))] : 0;
2304
2305                                                         // Get mask of allowed shading rates
2306                                                         deInt32 expectedMasks = Simulate(pipelineRate, primitiveRate, attachmentRate);
2307
2308                                                         if (!(expectedMasks & (1 << rate)))
2309                                                         {
2310                                                                 log << tcu::TestLog::Message << std::hex << "unexpected shading rate. failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ") "
2311                                                                                                                                                         "result rate 0x" << rate << " mask of expected rates 0x" << expectedMasks <<
2312                                                                                                                                                         " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate << tcu::TestLog::EndMessage;
2313                                                                 res = QP_TEST_RESULT_FAIL;
2314                                                                 continue;
2315                                                         }
2316                                                         // Check that not all fragments are downgraded to 1x1
2317                                                         if (rate == 0 && expectedMasks != 1)
2318                                                                 numUnexpected1x1Samples++;
2319                                                         numTotalSamples++;
2320
2321                                                         // Check that gl_FragDepth = primID / NUM_TRIANGLES
2322                                                         if (m_data.fragDepth)
2323                                                         {
2324                                                                 float *dsample = &depthptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2325                                                                 float expected = (float)primID / NUM_TRIANGLES;
2326                                                                 if (fabs(*dsample - expected) > 0.01)
2327                                                                 {
2328                                                                         log << tcu::TestLog::Message << std::hex << "depth write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *dsample << " expected " << expected << tcu::TestLog::EndMessage;
2329                                                                         res = QP_TEST_RESULT_FAIL;
2330                                                                         continue;
2331                                                                 }
2332                                                         }
2333
2334                                                         // Check that stencil value = primID
2335                                                         if (m_data.fragStencil)
2336                                                         {
2337                                                                 deUint32 *ssample = &stencilptr[((layer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s];
2338                                                                 if (*ssample != primID)
2339                                                                 {
2340                                                                         log << tcu::TestLog::Message << std::hex << "stencil write failed pixel (0x" << x << ",0x" << y << ",sample 0x" << s << ")=" << *ssample << " expected " << primID << tcu::TestLog::EndMessage;
2341                                                                         res = QP_TEST_RESULT_FAIL;
2342                                                                         continue;
2343                                                                 }
2344                                                         }
2345
2346                                                         // Check that primitives are in the right viewport/scissor
2347                                                         if (m_data.multiViewport)
2348                                                         {
2349                                                                 VkRect2D *scissor = &scissors[primID & 1];
2350                                                                 if ((int)x < scissor->offset.x || (int)x >= (int)(scissor->offset.x + scissor->extent.width) ||
2351                                                                         (int)y < scissor->offset.y || (int)y >= (int)(scissor->offset.y + scissor->extent.height))
2352                                                                 {
2353                                                                         log << tcu::TestLog::Message << std::hex << "primitive found outside of expected viewport (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << tcu::TestLog::EndMessage;
2354                                                                         res = QP_TEST_RESULT_FAIL;
2355                                                                         continue;
2356                                                                 }
2357                                                         }
2358
2359                                                         // Check that primitives are in the right layer
2360                                                         if (m_data.colorLayered)
2361                                                         {
2362                                                                 if (layer != ((primID & 2)>>1))
2363                                                                 {
2364                                                                         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;
2365                                                                         res = QP_TEST_RESULT_FAIL;
2366                                                                         continue;
2367                                                                 }
2368                                                         }
2369
2370                                                         // Check that multiview broadcasts the same primitive to both layers
2371                                                         if (m_data.multiView)
2372                                                         {
2373                                                                 deUint32 otherLayer = layer^1;
2374                                                                 deUint32 *othersample = &colorptr[4*(((otherLayer * m_data.framebufferDim.height + y) * m_data.framebufferDim.width + x)*m_data.samples + s)];
2375                                                                 deUint32 otherPrimID = othersample[2] >> 24;
2376                                                                 if (primID != otherPrimID)
2377                                                                 {
2378                                                                         log << tcu::TestLog::Message << std::hex << "multiview primitive mismatch (0x" << x << ",0x" << y << ",sample 0x" << s << ") primID=" << primID << "  otherPrimID=" << otherPrimID << tcu::TestLog::EndMessage;
2379                                                                         res = QP_TEST_RESULT_FAIL;
2380                                                                         continue;
2381                                                                 }
2382                                                         }
2383
2384                                                         // Loop over all samples in the same fragment
2385                                                         for (deUint32 fx = fragMinX; fx < fragMaxX; ++fx)
2386                                                         {
2387                                                                 for (deUint32 fy = fragMinY; fy < fragMaxY; ++fy)
2388                                                                 {
2389                                                                         for (deInt32 fs = 0; fs < m_data.samples; ++fs)
2390                                                                         {
2391                                                                                 deUint32 *fsample = &colorptr[4*(((layer * m_data.framebufferDim.height + fy) * m_data.framebufferDim.width + fx)*m_data.samples + fs)];
2392                                                                                 deUint32 frate = fsample[0];
2393                                                                                 deUint32 fprimID = fsample[2] >> 24;
2394                                                                                 deUint32 fatomVal = fsample[2] & 0xFFFFFF;
2395
2396                                                                                 // If we write out the sample mask value, check that the samples in the
2397                                                                                 // mask must not be uncovered, and that samples not in the mask must not
2398                                                                                 // be covered by this primitive
2399                                                                                 if (m_data.useSampleMaskIn)
2400                                                                                 {
2401                                                                                         int p = pixelsX * pixelsY - ((fx - fragMinX) + pixelsX * (fy - fragMinY)) - 1;
2402                                                                                         int sampleIdx = fs + m_data.samples * p;
2403
2404                                                                                         if ((sample[1] & (1 << sampleIdx)) && fsample[2] == 0)
2405                                                                                         {
2406                                                                                                 log << tcu::TestLog::Message << std::hex << "sample set in sampleMask but not written (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2407                                                                                                 res = QP_TEST_RESULT_FAIL;
2408                                                                                                 continue;
2409                                                                                         }
2410                                                                                         if (!(sample[1] & (1 << sampleIdx)) && fsample[2] != 0 && fprimID == primID)
2411                                                                                         {
2412                                                                                                 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;
2413                                                                                                 res = QP_TEST_RESULT_FAIL;
2414                                                                                                 continue;
2415                                                                                         }
2416                                                                                 }
2417
2418                                                                                 // If conservative raster is enabled, or custom sample locations all at the center, check that
2419                                                                                 // samples in the same pixel must be covered.
2420                                                                                 if (m_data.conservativeEnable ||
2421                                                                                         (m_data.sampleLocations && m_context.getFragmentShadingRateProperties().fragmentShadingRateWithCustomSampleLocations))
2422                                                                                 {
2423                                                                                         // If it's in the same pixel, expect it to be fully covered.
2424                                                                                         if (fx == x && fy == y && fsample[2] == 0)
2425                                                                                         {
2426                                                                                                 log << tcu::TestLog::Message << std::hex << "pixel not fully covered (0x" << fx << ",0x" << fy << ",sample 0x" << fs << ")" << tcu::TestLog::EndMessage;
2427                                                                                                 res = QP_TEST_RESULT_FAIL;
2428                                                                                                 continue;
2429                                                                                         }
2430                                                                                 }
2431
2432                                                                                 if (fsample[2] == 0)
2433                                                                                         continue;
2434
2435                                                                                 // If the primitive matches this sample, then it must have the same rate and
2436                                                                                 // atomic value
2437                                                                                 if (fprimID == primID)
2438                                                                                 {
2439                                                                                         if (rate != frate || (atomVal != fatomVal && !(m_data.sampleShadingEnable || m_data.sampleShadingInput)))
2440                                                                                         {
2441                                                                                                 log << tcu::TestLog::Message << std::hex << "failed pixel (0x" << x << ",0x" << y << ",sample " << s << ")=0x" << ((primID<<24)|atomVal) <<
2442                                                                                                                                                                                         " compared to (0x" << fx << ",0x" << fy << ",sample " << fs << ")=0x" << ((fprimID<<24)|fatomVal) <<
2443                                                                                                                                                                                         " pipelineRate=0x" << pipelineRate << " primitiveRate=0x" << primitiveRate << " attachmentRate =0x" << attachmentRate <<
2444                                                                                                                                                                                         tcu::TestLog::EndMessage;
2445                                                                                                 res = QP_TEST_RESULT_FAIL;
2446                                                                                         }
2447                                                                                 }
2448                                                                         }
2449                                                                 }
2450                                                         }
2451                                                 }
2452                                         }
2453                                 }
2454                         }
2455                         if (res == QP_TEST_RESULT_FAIL)
2456                                 break;
2457                 }
2458         }
2459         // All samples were coerced to 1x1, unexpected
2460         if (res == QP_TEST_RESULT_PASS &&
2461                 numTotalSamples != 0 &&
2462                 numUnexpected1x1Samples == numTotalSamples &&
2463                 numTotalSamples > 16)
2464         {
2465                 log << tcu::TestLog::Message << std::hex << "Quality warning - all fragments used 1x1" << tcu::TestLog::EndMessage;
2466                 res = QP_TEST_RESULT_QUALITY_WARNING;
2467         }
2468
2469         return tcu::TestStatus(res, qpGetTestResultName(res));
2470 }
2471
2472 #ifndef CTS_USES_VULKANSC
2473 void FSRTestInstance::beginSecondaryCmdBuffer(VkCommandBuffer cmdBuffer, VkFormat cbFormat, VkFormat dsFormat, VkRenderingFlagsKHR renderingFlags) const
2474 {
2475         VkCommandBufferInheritanceRenderingInfoKHR inheritanceRenderingInfo
2476         {
2477                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR,                // VkStructureType                                      sType;
2478                 DE_NULL,                                                                                                                                // const void*                                          pNext;
2479                 renderingFlags,                                                                                                                 // VkRenderingFlagsKHR                          flags;
2480                 m_data.multiView ? 0x3 : 0u,                                                                                    // uint32_t                                                     viewMask;
2481                 1u,                                                                                                                                             // uint32_t                                                     colorAttachmentCount;
2482                 &cbFormat,                                                                                                                              // const VkFormat*                                      pColorAttachmentFormats;
2483                 dsFormat,                                                                                                                               // VkFormat                                                     depthAttachmentFormat;
2484                 dsFormat,                                                                                                                               // VkFormat                                                     stencilAttachmentFormat;
2485                 m_data.samples,                                                                                                                 // VkSampleCountFlagBits                        rasterizationSamples;
2486         };
2487         const VkCommandBufferInheritanceInfo bufferInheritanceInfo = initVulkanStructure(&inheritanceRenderingInfo);
2488
2489         VkCommandBufferUsageFlags usageFlags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
2490         if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
2491                 usageFlags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
2492
2493         const VkCommandBufferBeginInfo commandBufBeginParams
2494         {
2495                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                                                    // VkStructureType                                      sType;
2496                 DE_NULL,                                                                                                                                // const void*                                          pNext;
2497                 usageFlags,                                                                                                                             // VkCommandBufferUsageFlags            flags;
2498                 &bufferInheritanceInfo
2499         };
2500
2501         const DeviceInterface& vk = m_context.getDeviceInterface();
2502         VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &commandBufBeginParams));
2503 }
2504
2505 void FSRTestInstance::beginDynamicRender(VkCommandBuffer cmdBuffer, VkImageView srImageView, VkImageLayout srImageLayout,
2506                                                                                  const VkExtent2D& srTexelSize, VkImageView cbImageView, VkImageView dsImageView,
2507                                                                                  const VkClearValue& clearColor, const VkClearValue& clearDepthStencil,
2508                                                                                  VkRenderingFlagsKHR renderingFlags) const
2509 {
2510         const DeviceInterface&  vk                      = m_context.getDeviceInterface();
2511         VkRect2D                                renderArea      = makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height);
2512
2513         VkRenderingFragmentShadingRateAttachmentInfoKHR shadingRateAttachmentInfo
2514         {
2515                 VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,  // VkStructureType              sType;
2516                 DE_NULL,                                                                                                                                // const void*                  pNext;
2517                 m_data.useAttachment() ? srImageView : DE_NULL,                                                 // VkImageView                  imageView;
2518                 srImageLayout,                                                                                                                  // VkImageLayout                imageLayout;
2519                 srTexelSize                                                                                                                             // VkExtent2D                   shadingRateAttachmentTexelSize;
2520         };
2521
2522         VkRenderingAttachmentInfoKHR colorAttachment
2523         {
2524                 vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,                                    // VkStructureType                                              sType;
2525                 DE_NULL,                                                                                                                                // const void*                                                  pNext;
2526                 cbImageView,                                                                                                                    // VkImageView                                                  imageView;
2527                 VK_IMAGE_LAYOUT_GENERAL,                                                                                                // VkImageLayout                                                imageLayout;
2528                 VK_RESOLVE_MODE_NONE,                                                                                                   // VkResolveModeFlagBits                                resolveMode;
2529                 DE_NULL,                                                                                                                                // VkImageView                                                  resolveImageView;
2530                 VK_IMAGE_LAYOUT_UNDEFINED,                                                                                              // VkImageLayout                                                resolveImageLayout;
2531                 VK_ATTACHMENT_LOAD_OP_LOAD,                                                                                             // VkAttachmentLoadOp                                   loadOp;
2532                 VK_ATTACHMENT_STORE_OP_STORE,                                                                                   // VkAttachmentStoreOp                                  storeOp;
2533                 clearColor                                                                                                                              // VkClearValue                                                 clearValue;
2534         };
2535
2536         std::vector<VkRenderingAttachmentInfoKHR> depthStencilAttachments(2,
2537                 {
2538                         VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,                                        // VkStructureType                                              sType;
2539                         DE_NULL,                                                                                                                        // const void*                                                  pNext;
2540                         dsImageView,                                                                                                            // VkImageView                                                  imageView;
2541                         VK_IMAGE_LAYOUT_GENERAL,                                                                                        // VkImageLayout                                                imageLayout;
2542                         VK_RESOLVE_MODE_NONE,                                                                                           // VkResolveModeFlagBits                                resolveMode;
2543                         DE_NULL,                                                                                                                        // VkImageView                                                  resolveImageView;
2544                         VK_IMAGE_LAYOUT_UNDEFINED,                                                                                      // VkImageLayout                                                resolveImageLayout;
2545                         VK_ATTACHMENT_LOAD_OP_LOAD,                                                                                     // VkAttachmentLoadOp                                   loadOp;
2546                         VK_ATTACHMENT_STORE_OP_STORE,                                                                           // VkAttachmentStoreOp                                  storeOp;
2547                         clearDepthStencil                                                                                                       // VkClearValue                                                 clearValue;
2548                 });
2549
2550         vk::VkRenderingInfoKHR renderingInfo
2551         {
2552                 vk::VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
2553                 m_data.useAttachment() || m_data.useAttachmentWithoutImageView() ? &shadingRateAttachmentInfo : DE_NULL,
2554                 renderingFlags,                                                                                                                 // VkRenderingFlagsKHR                                  flags;
2555                 renderArea,                                                                                                                             // VkRect2D                                                             renderArea;
2556                 m_data.multiView ? 1 : m_data.numColorLayers,                                                   // deUint32                                                             layerCount;
2557                 m_data.multiView ? 0x3 : 0u,                                                                                    // deUint32                                                             viewMask;
2558                 1u,                                                                                                                                             // deUint32                                                             colorAttachmentCount;
2559                 &colorAttachment,                                                                                                               // const VkRenderingAttachmentInfoKHR*  pColorAttachments;
2560                 m_data.useDepthStencil ? &depthStencilAttachments[0] : DE_NULL,                 // const VkRenderingAttachmentInfoKHR*  pDepthAttachment;
2561                 m_data.useDepthStencil ? &depthStencilAttachments[1] : DE_NULL,                 // const VkRenderingAttachmentInfoKHR*  pStencilAttachment;
2562         };
2563
2564         vk.cmdBeginRendering(cmdBuffer, &renderingInfo);
2565 }
2566 #endif // CTS_USES_VULKANSC
2567
2568 void FSRTestInstance::preRenderCommands(VkCommandBuffer cmdBuffer, ImageWithMemory* cbImage, ImageWithMemory* dsImage,
2569                                                                                 ImageWithMemory* derivImage, deUint32 derivNumLevels,
2570                                                                                 ImageWithMemory* srImage, VkImageLayout srLayout, BufferWithMemory* srFillBuffer,
2571                                                                                 deUint32 numSRLayers, deUint32 srWidth, deUint32 srHeight, deUint32 srFillBpp,
2572                                                                                 const VkClearValue& clearColor, const VkClearValue& clearDepthStencil)
2573 {
2574         const DeviceInterface&  vk                                              = m_context.getDeviceInterface();
2575         const VkDevice                  device                                  = m_context.getDevice();
2576
2577         VkFlags                                 allPipelineStages               = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
2578                                                                                                           VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
2579                                                                                                           VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
2580                                                                                                           VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
2581                                                                                                           VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
2582                                                                                                           VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
2583                                                                                                           VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
2584
2585         if (m_data.geometryShader)
2586                 allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
2587
2588         VkImageMemoryBarrier imageBarrier
2589         {
2590                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType              sType
2591                 DE_NULL,                                                                        // const void*                  pNext
2592                 0u,                                                                                     // VkAccessFlags                srcAccessMask
2593                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                dstAccessMask
2594                 VK_IMAGE_LAYOUT_UNDEFINED,                                      // VkImageLayout                oldLayout
2595                 VK_IMAGE_LAYOUT_GENERAL,                                        // VkImageLayout                newLayout
2596                 VK_QUEUE_FAMILY_IGNORED,                                        // uint32_t                             srcQueueFamilyIndex
2597                 VK_QUEUE_FAMILY_IGNORED,                                        // uint32_t                             dstQueueFamilyIndex
2598                 cbImage->get(),                                                         // VkImage                              image
2599                 {
2600                         VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
2601                         0u,                                                                             // uint32_t                             baseMipLevel
2602                         VK_REMAINING_MIP_LEVELS,                                // uint32_t                             mipLevels,
2603                         0u,                                                                             // uint32_t                             baseArray
2604                         VK_REMAINING_ARRAY_LAYERS,                              // uint32_t                             arraySize
2605                 }
2606         };
2607
2608         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2609                                                         (VkDependencyFlags)0,
2610                                                         0, (const VkMemoryBarrier*)DE_NULL,
2611                                                         0, (const VkBufferMemoryBarrier*)DE_NULL,
2612                                                         1, &imageBarrier);
2613
2614         imageBarrier.image = derivImage->get();
2615         imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
2616
2617         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2618                                                         (VkDependencyFlags)0,
2619                                                         0, (const VkMemoryBarrier*)DE_NULL,
2620                                                         0, (const VkBufferMemoryBarrier*)DE_NULL,
2621                                                         1, &imageBarrier);
2622
2623         // Clear level to 1<<level
2624         for (deUint32 i = 0; i < derivNumLevels; ++i)
2625         {
2626                 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, i, 1u, 0u, 1u);
2627                 VkClearValue clearLevelColor = makeClearValueColorU32(1<<i,0,0,0);
2628                 vk.cmdClearColorImage(cmdBuffer, derivImage->get(), VK_IMAGE_LAYOUT_GENERAL, &clearLevelColor.color, 1, &range);
2629         }
2630
2631         // Clear color buffer to transparent black
2632         {
2633                 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
2634                 vk.cmdClearColorImage(cmdBuffer, cbImage->get(), VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);
2635         }
2636
2637         // Clear depth and stencil
2638         if (m_data.useDepthStencil)
2639         {
2640                 VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 1u, 0u, VK_REMAINING_ARRAY_LAYERS);
2641                 VkImageMemoryBarrier dsBarrier = imageBarrier;
2642                 dsBarrier.image = dsImage->get();
2643                 dsBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
2644                 dsBarrier.subresourceRange = range;
2645                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2646                                                                 0u, // dependencyFlags
2647                                                                 0u, nullptr,
2648                                                                 0u, nullptr,
2649                                                                 1u, &dsBarrier);
2650                 vk.cmdClearDepthStencilImage(cmdBuffer, dsImage->get(), VK_IMAGE_LAYOUT_GENERAL, &clearDepthStencil.depthStencil, 1, &range);
2651         }
2652
2653         // Initialize shading rate image with varying values
2654         if (m_data.useAttachment())
2655         {
2656                 imageBarrier.image = srImage->get();
2657                 imageBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
2658
2659                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2660                                                                 (VkDependencyFlags)0,
2661                                                                 0, (const VkMemoryBarrier*)DE_NULL,
2662                                                                 0, (const VkBufferMemoryBarrier*)DE_NULL,
2663                                                                 1, &imageBarrier);
2664
2665                 deUint8 *fillPtr = (deUint8 *)srFillBuffer->getAllocation().getHostPtr();
2666                 for (deUint32 layer = 0; layer < numSRLayers; ++layer)
2667                 {
2668                         for (deUint32 x = 0; x < srWidth; ++x)
2669                         {
2670                                 for (deUint32 y = 0; y < srHeight; ++y)
2671                                 {
2672                                         deUint32 idx = (layer*srHeight + y)*srWidth + x;
2673                                         deUint8 val = (deUint8)SanitizeRate(idx & 0xF);
2674                                         // actual shading rate is always in the LSBs of the first byte of a texel
2675                                         fillPtr[srFillBpp*idx] = val;
2676                                 }
2677                         }
2678                 }
2679                 flushAlloc(vk, device, srFillBuffer->getAllocation());
2680
2681                 const VkBufferImageCopy copyRegion
2682                 {
2683                         0u,                                                                                                                                     // VkDeviceSize                 bufferOffset;
2684                         0u,                                                                                                                                     // deUint32                             bufferRowLength;
2685                         0u,                                                                                                                                     // deUint32                             bufferImageHeight;
2686                         {
2687                                 VK_IMAGE_ASPECT_COLOR_BIT,                                                                              // VkImageAspectFlags   aspect;
2688                                 0u,                                                                                                                             // deUint32                             mipLevel;
2689                                 0u,                                                                                                                             // deUint32                             baseArrayLayer;
2690                                 numSRLayers,                                                                                                    // deUint32                             layerCount;
2691                         },                                                                                                                                      // VkImageSubresourceLayers imageSubresource;
2692                         { 0, 0, 0 },                                                                                                            // VkOffset3D                   imageOffset;
2693                         { srWidth, srHeight, 1 },                                                                                       // VkExtent3D                   imageExtent;
2694                 };
2695
2696                 vk.cmdCopyBufferToImage(cmdBuffer, srFillBuffer->get(), srImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
2697
2698                 imageBarrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
2699                 imageBarrier.newLayout = srLayout;
2700
2701                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2702                                                                 (VkDependencyFlags)0,
2703                                                                 0, (const VkMemoryBarrier*)DE_NULL,
2704                                                                 0, (const VkBufferMemoryBarrier*)DE_NULL,
2705                                                                 1, &imageBarrier);
2706         }
2707
2708         VkMemoryBarrier memBarrier
2709         {
2710                 VK_STRUCTURE_TYPE_MEMORY_BARRIER,       // sType
2711                 DE_NULL,                                                        // pNext
2712                 0u,                                                                     // srcAccessMask
2713                 0u,                                                                     // dstAccessMask
2714         };
2715
2716         memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
2717         memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
2718         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, allPipelineStages,
2719                                                   0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2720 }
2721
2722 void FSRTestInstance::beginLegacyRender(VkCommandBuffer cmdBuffer, VkRenderPass renderPass, VkFramebuffer framebuffer,
2723                                                                                 VkImageView srImageView, VkImageView cbImageView, VkImageView dsImageView, bool imagelessFB) const
2724 {
2725         const DeviceInterface&  vk                      = m_context.getDeviceInterface();
2726         VkRect2D                                renderArea      = makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height);
2727
2728         std::vector<VkImageView> attachments = { cbImageView };
2729         if (m_data.useAttachment())
2730                 attachments.push_back(srImageView);
2731         if (m_data.useDepthStencil)
2732                 attachments.push_back(dsImageView);
2733
2734         const VkRenderPassAttachmentBeginInfo renderPassAttachmentBeginInfo
2735         {
2736                 VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,            // VkStructureType              sType;
2737                 DE_NULL,                                                                                                        // const void*                  pNext;
2738                 (deUint32)attachments.size(),                                                           // deUint32                             attachmentCount;
2739                 &attachments[0]                                                                                         // const VkImageView*   pAttachments;
2740         };
2741
2742         beginRenderPass(vk, cmdBuffer, renderPass, framebuffer, renderArea,
2743                                         0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE, imagelessFB ? &renderPassAttachmentBeginInfo : DE_NULL);
2744 }
2745
2746 void FSRTestInstance::drawCommands(VkCommandBuffer                                                                      cmdBuffer,
2747                                                                    std::vector<GraphicsPipelineWrapper>&                        pipelines,
2748                                                                    const std::vector<VkViewport>&                                       viewports,
2749                                                                    const std::vector<VkRect2D>&                                         scissors,
2750                                                                    const VkPipelineLayout                                                       pipelineLayout,
2751                                                                    const VkRenderPass                                                           renderPass,
2752                                                                    const VkPipelineVertexInputStateCreateInfo*          vertexInputState,
2753                                                                    const VkPipelineDynamicStateCreateInfo*                      dynamicState,
2754                                                                    const VkPipelineRasterizationStateCreateInfo*        rasterizationState,
2755                                                                    const VkPipelineDepthStencilStateCreateInfo*         depthStencilState,
2756                                                                    const VkPipelineMultisampleStateCreateInfo*          multisampleState,
2757                                                                    VkPipelineFragmentShadingRateStateCreateInfoKHR*     shadingRateState,
2758                                                                    PipelineRenderingCreateInfoWrapper                           dynamicRenderingState,
2759                                                                    const VkShaderModule                                                         vertShader,
2760                                                                    const VkShaderModule                                                         geomShader,
2761                                                                    const VkShaderModule                                                         meshShader,
2762                                                                    const VkShaderModule                                                         fragShader,
2763                                                                    const std::vector<VkDescriptorSet>&                          descriptorSets,
2764                                                                    VkBuffer                                                                                     vertexBuffer,
2765                                                                    const uint32_t                                                                       pushConstantSize)
2766 {
2767         const DeviceInterface&  vk              = m_context.getDeviceInterface();
2768         const VkDevice                  device  = m_context.getDevice();
2769         const bool                              useMesh = (meshShader != DE_NULL);
2770
2771 #ifdef CTS_USES_VULKANSC
2772         if (useMesh)
2773                 DE_ASSERT(false);
2774 #endif // CTS_USES_VULKANSC
2775
2776         VkFlags allShaderStages = VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
2777
2778         if (useMesh)
2779         {
2780 #ifndef CTS_USES_VULKANSC
2781                 allShaderStages |= VK_SHADER_STAGE_MESH_BIT_EXT;
2782 #endif // CTS_USES_VULKANSC
2783         }
2784         else
2785         {
2786                 allShaderStages |= VK_SHADER_STAGE_VERTEX_BIT;
2787                 if (m_data.geometryShader)
2788                         allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
2789         }
2790
2791         VkPipelineCreateFlags pipelineCreateFlags = (VkPipelineCreateFlags)0;
2792
2793 #ifndef CTS_USES_VULKANSC
2794         if (m_data.groupParams->useDynamicRendering)
2795                 pipelineCreateFlags |= VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
2796 #endif // CTS_USES_VULKANSC
2797
2798         vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, static_cast<uint32_t>(descriptorSets.size()), de::dataOrNull(descriptorSets), 0, DE_NULL);
2799
2800         PipelineRenderingCreateInfoWrapper              pipelineRenderingCreateInfo = dynamicRenderingState;
2801 #ifndef CTS_USES_VULKANSC
2802         vk::VkPipelineRenderingCreateInfo               pipelineRenderingCreateInfoWithGarbage;
2803         if (m_data.garbageAttachment)
2804         {
2805                 pipelineRenderingCreateInfoWithGarbage = *dynamicRenderingState.ptr;
2806                 pipelineRenderingCreateInfoWithGarbage.colorAttachmentCount             = 99999u;
2807                 pipelineRenderingCreateInfoWithGarbage.pColorAttachmentFormats  = reinterpret_cast<VkFormat *>(0x11);
2808
2809                 pipelineRenderingCreateInfo = &pipelineRenderingCreateInfoWithGarbage;
2810         }
2811 #endif
2812
2813         // If using dynamic state, create a single graphics pipeline and bind it
2814         if (m_data.useDynamicState)
2815         {
2816                 pipelines.emplace_back(vk, device, m_data.groupParams->pipelineConstructionType, pipelineCreateFlags);
2817                 auto& pipeline = pipelines.back();
2818
2819                 pipeline
2820                         .setDefaultColorBlendState()
2821                         .setDynamicState(dynamicState);
2822
2823                 if (useMesh)
2824                 {
2825 #ifndef CTS_USES_VULKANSC
2826                         pipeline
2827                                 .setupPreRasterizationMeshShaderState(viewports,
2828                                                                                                           scissors,
2829                                                                                                           pipelineLayout,
2830                                                                                                           renderPass,
2831                                                                                                           0u,
2832                                                                                                           DE_NULL,
2833                                                                                                           meshShader,
2834                                                                                                           rasterizationState,
2835                                                                                                           nullptr,
2836                                                                                                           nullptr,
2837                                                                                                           shadingRateState,
2838                                                                                                           pipelineRenderingCreateInfo);
2839 #endif // CTS_USES_VULKANSC
2840                 }
2841                 else
2842                 {
2843                         pipeline
2844                                 .setupVertexInputState(vertexInputState)
2845                                 .setupPreRasterizationShaderState(viewports,
2846                                                                                                   scissors,
2847                                                                                                   pipelineLayout,
2848                                                                                                   renderPass,
2849                                                                                                   0u,
2850                                                                                                   vertShader,
2851                                                                                                   rasterizationState,
2852                                                                                                   DE_NULL,
2853                                                                                                   DE_NULL,
2854                                                                                                   geomShader,
2855                                                                                                   DE_NULL,
2856                                                                                                   shadingRateState,
2857                                                                                                   pipelineRenderingCreateInfo);
2858                 }
2859
2860                 pipeline
2861                         .setupFragmentShaderState(pipelineLayout,
2862                                                                           renderPass,
2863                                                                           0u,
2864                                                                           fragShader,
2865                                                                           depthStencilState,
2866                                                                           multisampleState)
2867                         .setupFragmentOutputState(renderPass, 0u, DE_NULL, multisampleState)
2868                         .setMonolithicPipelineLayout(pipelineLayout)
2869                         .buildPipeline();
2870
2871                 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.getPipeline());
2872         }
2873
2874         // Push constant block (must match shaders).
2875         struct
2876         {
2877                 int32_t         shadingRate;
2878                 uint32_t        instanceIndex;
2879         } pushConstantBlock;
2880
2881         for (deInt32 i = 0; i < NUM_TRIANGLES; ++i)
2882         {
2883                 if (!useMesh)
2884                 {
2885                         // Bind vertex attributes pointing to the next triangle
2886                         VkDeviceSize vertexBufferOffset = i * 3 * 2 * sizeof(float);
2887                         vk.cmdBindVertexBuffers(cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
2888                 }
2889
2890                 // Put primitive shading rate and instance index (used in mesh shading cases) in push constants.
2891                 pushConstantBlock.shadingRate   = PrimIDToPrimitiveShadingRate(i);
2892                 pushConstantBlock.instanceIndex = static_cast<uint32_t>(i);
2893                 vk.cmdPushConstants(cmdBuffer, pipelineLayout, allShaderStages, 0, pushConstantSize, &pushConstantBlock);
2894
2895                 if (m_data.useDynamicState)
2896                 {
2897                         VkExtent2D fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2898                         vk.cmdSetFragmentShadingRateKHR(cmdBuffer, &fragmentSize, m_data.combinerOp);
2899                 }
2900                 else
2901                 {
2902                         // Create a new pipeline with the desired pipeline shading rate
2903                         shadingRateState->fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
2904
2905                         pipelines.emplace_back(vk, device, m_data.groupParams->pipelineConstructionType, pipelineCreateFlags);
2906                         auto& pipeline = pipelines.back();
2907
2908                         pipeline
2909                                 .setDefaultColorBlendState()
2910                                 .setDynamicState(dynamicState);
2911
2912                         if (useMesh)
2913                         {
2914 #ifndef CTS_USES_VULKANSC
2915                                 pipeline
2916                                         .setupPreRasterizationMeshShaderState(viewports,
2917                                                                                                                   scissors,
2918                                                                                                                   pipelineLayout,
2919                                                                                                                   renderPass,
2920                                                                                                                   0u,
2921                                                                                                                   DE_NULL,
2922                                                                                                                   meshShader,
2923                                                                                                                   rasterizationState,
2924                                                                                                                   nullptr,
2925                                                                                                                   nullptr,
2926                                                                                                                   shadingRateState,
2927                                                                                                                   dynamicRenderingState);
2928 #endif // CTS_USES_VULKANSC
2929                         }
2930                         else
2931                         {
2932                                 pipeline
2933                                         .setupVertexInputState(vertexInputState)
2934                                         .setupPreRasterizationShaderState(viewports,
2935                                                                                                           scissors,
2936                                                                                                           pipelineLayout,
2937                                                                                                           renderPass,
2938                                                                                                           0u,
2939                                                                                                           vertShader,
2940                                                                                                           rasterizationState,
2941                                                                                                           DE_NULL,
2942                                                                                                           DE_NULL,
2943                                                                                                           geomShader,
2944                                                                                                           DE_NULL,
2945                                                                                                           shadingRateState,
2946                                                                                                           dynamicRenderingState);
2947                         }
2948
2949                         pipeline
2950                                 .setupFragmentShaderState(pipelineLayout,
2951                                                                                   renderPass,
2952                                                                                   0u,
2953                                                                                   fragShader,
2954                                                                                   depthStencilState,
2955                                                                                   multisampleState)
2956 #ifndef CTS_USES_VULKANSC
2957                                 .setRenderingColorAttachmentsInfo(dynamicRenderingState)
2958 #endif
2959                                 .setupFragmentOutputState(renderPass, 0u, DE_NULL, multisampleState)
2960                                 .setMonolithicPipelineLayout(pipelineLayout)
2961                                 .buildPipeline();
2962
2963                         vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.getPipeline());
2964                 }
2965
2966                 if (useMesh)
2967                 {
2968 #ifndef CTS_USES_VULKANSC
2969                         // Create a single workgroup to draw one triangle. The "primitive id" will be in the push constants.
2970                         vk.cmdDrawMeshTasksEXT(cmdBuffer, 1u, 1u, 1u);
2971 #endif // CTS_USES_VULKANSC
2972                 }
2973                 else
2974                 {
2975                         // Draw one triangle, with "primitive ID" in gl_InstanceIndex
2976                         vk.cmdDraw(cmdBuffer, 3u, 1, 0u, i);
2977                 }
2978         }
2979 }
2980
2981 }       // anonymous
2982
2983 void createBasicTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* parentGroup, SharedGroupParams groupParams)
2984 {
2985         typedef struct
2986         {
2987                 deUint32                                count;
2988                 const char*                             name;
2989                 const char*                             description;
2990         } TestGroupCase;
2991
2992         typedef struct
2993         {
2994                 VkExtent2D                              count;
2995                 const char*                             name;
2996                 const char*                             description;
2997         } TestGroupCase2D;
2998
2999         typedef struct
3000         {
3001                 AttachmentUsage                 usage;
3002                 const char*                             name;
3003                 const char*                             description;
3004         } TestGroupUsageCase;
3005
3006         TestGroupCase groupCases[] =
3007         {
3008                 { 0,    "basic",                                        "basic tests"                                                                                   },
3009                 { 1,    "apisamplemask",                        "use pSampleMask"                                                                               },
3010                 { 2,    "samplemaskin",                         "use gl_SampleMaskIn"                                                                   },
3011                 { 3,    "conservativeunder",            "conservative underestimation"                                                  },
3012                 { 4,    "conservativeover",                     "conservative overestimation"                                                   },
3013                 { 5,    "fragdepth",                            "depth shader output"                                                                   },
3014                 { 6,    "fragstencil",                          "stencil shader output"                                                                 },
3015                 { 7,    "multiviewport",                        "multiple viewports and gl_ViewportIndex"                               },
3016                 { 8,    "colorlayered",                         "multiple layer color, single layer shading rate"               },
3017                 { 9,    "srlayered",                            "multiple layer color, multiple layers shading rate"    },
3018                 { 10,   "multiview",                            "multiview"                                                                                             },
3019                 { 11,   "multiviewsrlayered",           "multiview and multilayer shading rate"                                 },
3020                 { 12,   "multiviewcorrelation",         "multiview with correlation mask"                                               },
3021                 { 13,   "interlock",                            "fragment shader interlock"                                                             },
3022                 { 14,   "samplelocations",                      "custom sample locations"                                                               },
3023                 { 15,   "sampleshadingenable",          "enable sample shading in createinfo"                                   },
3024                 { 16,   "sampleshadinginput",           "enable sample shading by using gl_SampleID"                    },
3025 #ifndef CTS_USES_VULKANSC
3026                 { 17,   "fragdepth_early_late",         "depth shader output"                                                                   },
3027                 { 18,   "fragstencil_early_late",       "stencil shader output"                                                                 },
3028 #endif
3029         };
3030
3031         TestGroupCase dynCases[] =
3032         {
3033                 { 1,    "dynamic",      "uses dynamic shading rate state"       },
3034                 { 0,    "static",       "uses static shading rate state"        },
3035         };
3036
3037         TestGroupUsageCase attCases[] =
3038         {
3039                 { AttachmentUsage::NO_ATTACHMENT,                                               "noattachment",                         "no shading rate attachment"                                    },
3040                 { AttachmentUsage::WITH_ATTACHMENT,                                             "attachment",                           "has shading rate attachment"                                   },
3041                 { AttachmentUsage::NO_ATTACHMENT_PTR,                                   "noattachmentptr",                      "no shading rate attachment pointer"                    },
3042                 { AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW,   "attachment_noimageview",       "has shading rate attachment without imageview" },
3043         };
3044
3045         TestGroupCase shdCases[] =
3046         {
3047                 { 0,    "noshaderrate", "shader doesn't write rate"     },
3048                 { 1,    "shaderrate",   "shader writes rate"    },
3049         };
3050
3051         TestGroupCase combCases[] =
3052         {
3053                 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,        "keep",         "keep"  },
3054                 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR,     "replace",      "replace"       },
3055                 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR,         "min",          "min"   },
3056                 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR,         "max",          "max"   },
3057                 { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR,         "mul",          "mul"   },
3058         };
3059
3060         TestGroupCase2D extentCases[] =
3061         {
3062                 { {1,   1},             "1x1",          "1x1"           },
3063                 { {4,   4},             "4x4",          "4x4"           },
3064                 { {33,  35},    "33x35",        "33x35"         },
3065                 { {151, 431},   "151x431",      "151x431"       },
3066                 { {256, 256},   "256x256",      "256x256"       },
3067         };
3068
3069         TestGroupCase sampCases[] =
3070         {
3071                 { VK_SAMPLE_COUNT_1_BIT,        "samples1",             "1 raster sample"       },
3072                 { VK_SAMPLE_COUNT_2_BIT,        "samples2",             "2 raster samples"      },
3073                 { VK_SAMPLE_COUNT_4_BIT,        "samples4",             "4 raster samples"      },
3074                 { VK_SAMPLE_COUNT_8_BIT,        "samples8",             "8 raster samples"      },
3075                 { VK_SAMPLE_COUNT_16_BIT,       "samples16",    "16 raster samples"     },
3076         };
3077
3078         TestGroupCase shaderCases[] =
3079         {
3080                 { 0,    "vs",   "vertex shader only"                    },
3081                 { 1,    "gs",   "vertex and geometry shader"    },
3082 #ifndef CTS_USES_VULKANSC
3083                 { 2,    "ms",   "mesh shader"                                   },
3084 #endif // CTS_USES_VULKANSC
3085         };
3086
3087         deInt32 seed = 0;
3088
3089         for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(groupCases); groupNdx++)
3090         {
3091                 if (groupParams->useDynamicRendering && groupNdx == 12)
3092                         continue;
3093
3094                 if (groupParams->pipelineConstructionType != PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC)
3095                 {
3096                         // for graphics pipeline library we need to repeat only selected groups
3097                         if (std::set<int> { 2, 3, 4, 10, 11, 12, 13, 14, 15 }.count(groupNdx) == 0)
3098                                 continue;
3099                 }
3100
3101                 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, groupCases[groupNdx].name, groupCases[groupNdx].description));
3102                 for (int dynNdx = 0; dynNdx < DE_LENGTH_OF_ARRAY(dynCases); dynNdx++)
3103                 {
3104                         // reduce number of tests for dynamic rendering cases where secondary command buffer is used
3105                         if (groupParams->useSecondaryCmdBuffer && (dynNdx != 0))
3106                                 continue;
3107
3108                         de::MovePtr<tcu::TestCaseGroup> dynGroup(new tcu::TestCaseGroup(testCtx, dynCases[dynNdx].name, dynCases[dynNdx].description));
3109                         for (int attNdx = 0; attNdx < DE_LENGTH_OF_ARRAY(attCases); attNdx++)
3110                         {
3111                                 if (groupParams->useDynamicRendering && attCases[attNdx].usage == AttachmentUsage::NO_ATTACHMENT_PTR)
3112                                         continue;
3113
3114                                 // WITH_ATTACHMENT_WITHOUT_IMAGEVIEW is only for VkRenderingFragmentShadingRateAttachmentInfoKHR.
3115                                 if (!groupParams->useDynamicRendering && attCases[attNdx].usage == AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW)
3116                                         continue;
3117
3118                                 de::MovePtr<tcu::TestCaseGroup> attGroup(new tcu::TestCaseGroup(testCtx, attCases[attNdx].name, attCases[attNdx].description));
3119                                 for (int shdNdx = 0; shdNdx < DE_LENGTH_OF_ARRAY(shdCases); shdNdx++)
3120                                 {
3121                                         de::MovePtr<tcu::TestCaseGroup> shdGroup(new tcu::TestCaseGroup(testCtx, shdCases[shdNdx].name, shdCases[shdNdx].description));
3122                                         for (int cmb0Ndx = 0; cmb0Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb0Ndx++)
3123                                         {
3124                                                 de::MovePtr<tcu::TestCaseGroup> cmb0Group(new tcu::TestCaseGroup(testCtx, combCases[cmb0Ndx].name, combCases[cmb0Ndx].description));
3125                                                 for (int cmb1Ndx = 0; cmb1Ndx < DE_LENGTH_OF_ARRAY(combCases); cmb1Ndx++)
3126                                                 {
3127                                                         de::MovePtr<tcu::TestCaseGroup> cmb1Group(new tcu::TestCaseGroup(testCtx, combCases[cmb1Ndx].name, combCases[cmb1Ndx].description));
3128                                                         for (int extNdx = 0; extNdx < DE_LENGTH_OF_ARRAY(extentCases); extNdx++)
3129                                                         {
3130                                                                 // reduce number of cases repeat every other extent case for graphics pipeline library
3131                                                                 if ((groupParams->pipelineConstructionType != PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC) && ((extNdx % 2) == 1))
3132                                                                         continue;
3133
3134                                                                 // reduce number of tests for dynamic rendering cases where secondary command buffer is used
3135                                                                 if (groupParams->useSecondaryCmdBuffer && (extNdx != 1))
3136                                                                         continue;
3137
3138                                                                 de::MovePtr<tcu::TestCaseGroup> extGroup(new tcu::TestCaseGroup(testCtx, extentCases[extNdx].name, extentCases[extNdx].description));
3139                                                                 for (int sampNdx = 0; sampNdx < DE_LENGTH_OF_ARRAY(sampCases); sampNdx++)
3140                                                                 {
3141                                                                         // reduce number of tests for dynamic rendering cases where secondary command buffer is used
3142                                                                         if (groupParams->useSecondaryCmdBuffer && (sampNdx != 1))
3143                                                                                 continue;
3144
3145                                                                         de::MovePtr<tcu::TestCaseGroup> sampGroup(new tcu::TestCaseGroup(testCtx, sampCases[sampNdx].name, sampCases[sampNdx].description));
3146                                                                         for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(shaderCases); shaderNdx++)
3147                                                                         {
3148                                                                                 // reduce number of tests for dynamic rendering cases where secondary command buffer is used
3149                                                                                 if (groupParams->useSecondaryCmdBuffer && (shaderNdx != 0))
3150                                                                                         continue;
3151
3152                                                                                 bool useApiSampleMask = groupNdx == 1;
3153                                                                                 bool useSampleMaskIn = groupNdx == 2;
3154                                                                                 bool consRast = groupNdx == 3 || groupNdx == 4;
3155                                                                                 bool fragDepth = groupNdx == 5 || groupNdx == 17;
3156                                                                                 bool fragStencil = groupNdx == 6 || groupNdx == 18;
3157                                                                                 bool multiViewport = groupNdx == 7;
3158                                                                                 bool colorLayered = groupNdx == 8 || groupNdx == 9;
3159                                                                                 bool srLayered = groupNdx == 9 || groupNdx == 11;
3160                                                                                 bool multiView = groupNdx == 10 || groupNdx == 11 || groupNdx == 12;
3161                                                                                 bool correlationMask = groupNdx == 12;
3162                                                                                 bool interlock = groupNdx == 13;
3163                                                                                 bool sampleLocations = groupNdx == 14;
3164                                                                                 bool sampleShadingEnable = groupNdx == 15;
3165                                                                                 bool sampleShadingInput = groupNdx == 16;
3166                                                                                 bool useGeometryShader = (shaderCases[shaderNdx].count == 1u);
3167                                                                                 bool useMeshShader = (shaderCases[shaderNdx].count == 2u);
3168                                                                                 bool earlyAndLateTest = groupNdx == 17 || groupNdx == 18;
3169
3170                                                                                 VkConservativeRasterizationModeEXT conservativeMode = (groupNdx == 3) ? VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT : VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT;
3171                                                                                 deUint32 numColorLayers = (colorLayered || multiView) ? 2u : 1u;
3172
3173                                                                                 // Don't bother with geometry shader if we're not testing shader writes
3174                                                                                 if (useGeometryShader && !shdCases[shdNdx].count)
3175                                                                                         continue;
3176
3177                                                                                 // reduce number of tests
3178                                                                                 if ((groupNdx != 0) &&
3179                                                                                         (!dynCases[dynNdx].count ||
3180                                                                                          !(combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb0Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR) ||
3181                                                                                          !(combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR || combCases[cmb1Ndx].count == VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR)))
3182                                                                                         continue;
3183
3184                                                                                 // Don't bother with geometry shader if we're testing conservative raster, sample mask, depth/stencil
3185                                                                                 if (useGeometryShader && (useApiSampleMask || useSampleMaskIn || consRast || fragDepth || fragStencil))
3186                                                                                         continue;
3187
3188                                                                                 // Don't bother with geometry shader if we're testing non-dynamic state
3189                                                                                 if (useGeometryShader && !dynCases[dynNdx].count)
3190                                                                                         continue;
3191
3192                                                                                 // Only test multiViewport/layered with shaderWritesRate
3193                                                                                 if ((multiViewport || colorLayered) && !shdCases[shdNdx].count)
3194                                                                                         continue;
3195
3196                                                                                 // Can't test layered shading rate attachment without an attachment
3197                                                                                 if (srLayered && attCases[attNdx].usage != AttachmentUsage::WITH_ATTACHMENT)
3198                                                                                         continue;
3199
3200                                                                                 CaseDef c
3201                                                                                 {
3202                                                                                         groupParams,                                                                                    // SharedGroupParams groupParams;
3203                                                                                         seed++,                                                                                                 // deInt32 seed;
3204                                                                                         extentCases[extNdx].count,                                                              // VkExtent2D framebufferDim;
3205                                                                                         (VkSampleCountFlagBits)sampCases[sampNdx].count,                // VkSampleCountFlagBits samples;
3206                                                                                         {
3207                                                                                                 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb0Ndx].count,
3208                                                                                                 (VkFragmentShadingRateCombinerOpKHR)combCases[cmb1Ndx].count
3209                                                                                         },                                                                                                              // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
3210                                                                                         attCases[attNdx].usage,                                                                 // AttachmentUsage attachmentUsage;
3211                                                                                         (bool)shdCases[shdNdx].count,                                                   // bool shaderWritesRate;
3212                                                                                         useGeometryShader,                                                                              // bool geometryShader;
3213                                                                                         useMeshShader,                                                                                  // bool meshShader;
3214                                                                                         (bool)dynCases[dynNdx].count,                                                   // bool useDynamicState;
3215                                                                                         useApiSampleMask,                                                                               // bool useApiSampleMask;
3216                                                                                         useSampleMaskIn,                                                                                // bool useSampleMaskIn;
3217                                                                                         consRast,                                                                                               // bool conservativeEnable;
3218                                                                                         conservativeMode,                                                                               // VkConservativeRasterizationModeEXT conservativeMode;
3219                                                                                         fragDepth || fragStencil,                                                               // bool useDepthStencil;
3220                                                                                         fragDepth,                                                                                              // bool fragDepth;
3221                                                                                         fragStencil,                                                                                    // bool fragStencil;
3222                                                                                         multiViewport,                                                                                  // bool multiViewport;
3223                                                                                         colorLayered,                                                                                   // bool colorLayered;
3224                                                                                         srLayered,                                                                                              // bool srLayered;
3225                                                                                         numColorLayers,                                                                                 // deUint32 numColorLayers;
3226                                                                                         multiView,                                                                                              // bool multiView;
3227                                                                                         correlationMask,                                                                                // bool correlationMask;
3228                                                                                         interlock,                                                                                              // bool interlock;
3229                                                                                         sampleLocations,                                                                                // bool sampleLocations;
3230                                                                                         sampleShadingEnable,                                                                    // bool sampleShadingEnable;
3231                                                                                         sampleShadingInput,                                                                             // bool sampleShadingInput;
3232                                                                                         false,                                                                                                  // bool sampleMaskTest;
3233                                                                                         earlyAndLateTest,                                                                               // bool earlyAndLateTest;
3234                                                                                         false,                                                                                                  // bool garbageAttachment;
3235                                                                                 };
3236
3237                                                                                 sampGroup->addChild(new FSRTestCase(testCtx, shaderCases[shaderNdx].name, shaderCases[shaderNdx].description, c));
3238                                                                         }
3239                                                                         extGroup->addChild(sampGroup.release());
3240                                                                 }
3241                                                                 cmb1Group->addChild(extGroup.release());
3242                                                         }
3243                                                         cmb0Group->addChild(cmb1Group.release());
3244                                                 }
3245                                                 shdGroup->addChild(cmb0Group.release());
3246                                         }
3247                                         attGroup->addChild(shdGroup.release());
3248                                 }
3249                                 dynGroup->addChild(attGroup.release());
3250                         }
3251                         group->addChild(dynGroup.release());
3252                 }
3253                 parentGroup->addChild(group.release());
3254         }
3255
3256         {
3257                 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "misc_tests", "Single tests that don't need to be part of above test matrix"));
3258
3259                 if (!groupParams->useSecondaryCmdBuffer)
3260                 {
3261                         group->addChild(new FSRTestCase(testCtx, "sample_mask_test", "", {
3262                                 groupParams,                                                                                    // SharedGroupParams groupParams;
3263                                 123,                                                                                                    // deInt32 seed;
3264                                 {32,  33},                                                                                              // VkExtent2D framebufferDim;
3265                                 VK_SAMPLE_COUNT_4_BIT,                                                                  // VkSampleCountFlagBits samples;
3266                                 {
3267                                         VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
3268                                         VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
3269                                 },                                                                                                              // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
3270                                 AttachmentUsage::NO_ATTACHMENT,                                                 // AttachmentUsage attachmentUsage;
3271                                 true,                                                                                                   // bool shaderWritesRate;
3272                                 false,                                                                                                  // bool geometryShader;
3273                                 false,                                                                                                  // bool meshShader;
3274                                 false,                                                                                                  // bool useDynamicState;
3275                                 true,                                                                                                   // bool useApiSampleMask;
3276                                 false,                                                                                                  // bool useSampleMaskIn;
3277                                 false,                                                                                                  // bool conservativeEnable;
3278                                 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT,   // VkConservativeRasterizationModeEXT conservativeMode;
3279                                 false,                                                                                                  // bool useDepthStencil;
3280                                 false,                                                                                                  // bool fragDepth;
3281                                 false,                                                                                                  // bool fragStencil;
3282                                 false,                                                                                                  // bool multiViewport;
3283                                 false,                                                                                                  // bool colorLayered;
3284                                 false,                                                                                                  // bool srLayered;
3285                                 1u,                                                                                                             // deUint32 numColorLayers;
3286                                 false,                                                                                                  // bool multiView;
3287                                 false,                                                                                                  // bool correlationMask;
3288                                 false,                                                                                                  // bool interlock;
3289                                 false,                                                                                                  // bool sampleLocations;
3290                                 false,                                                                                                  // bool sampleShadingEnable;
3291                                 false,                                                                                                  // bool sampleShadingInput;
3292                                 true,                                                                                                   // bool sampleMaskTest;
3293                                 false,                                                                                                  // bool earlyAndLateTest;
3294                                 false,                                                                                                  // bool garbageAttachment;
3295                         }));
3296                 }
3297
3298 #ifndef CTS_USES_VULKANSC
3299                 if (groupParams->useDynamicRendering && groupParams->pipelineConstructionType != vk::PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC)
3300                 {
3301                         group->addChild(new FSRTestCase(testCtx, "garbage_color_attachment", "", {
3302                                 groupParams,                                                                                    // SharedGroupParams groupParams;
3303                                 123,                                                                                                    // deInt32 seed;
3304                                 {32,  33},                                                                                              // VkExtent2D framebufferDim;
3305                                 VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits samples;
3306                                 {
3307                                         VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
3308                                         VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
3309                                 },                                                                                                              // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
3310                                 AttachmentUsage::NO_ATTACHMENT,                                                 // AttachmentUsage attachmentUsage;
3311                                 false,                                                                                                  // bool shaderWritesRate;
3312                                 false,                                                                                                  // bool geometryShader;
3313                                 false,                                                                                                  // bool meshShader;
3314                                 false,                                                                                                  // bool useDynamicState;
3315                                 false,                                                                                                  // bool useApiSampleMask;
3316                                 false,                                                                                                  // bool useSampleMaskIn;
3317                                 false,                                                                                                  // bool conservativeEnable;
3318                                 VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT,   // VkConservativeRasterizationModeEXT conservativeMode;
3319                                 false,                                                                                                  // bool useDepthStencil;
3320                                 false,                                                                                                  // bool fragDepth;
3321                                 false,                                                                                                  // bool fragStencil;
3322                                 false,                                                                                                  // bool multiViewport;
3323                                 false,                                                                                                  // bool colorLayered;
3324                                 false,                                                                                                  // bool srLayered;
3325                                 1u,                                                                                                             // deUint32 numColorLayers;
3326                                 false,                                                                                                  // bool multiView;
3327                                 false,                                                                                                  // bool correlationMask;
3328                                 false,                                                                                                  // bool interlock;
3329                                 false,                                                                                                  // bool sampleLocations;
3330                                 false,                                                                                                  // bool sampleShadingEnable;
3331                                 false,                                                                                                  // bool sampleShadingInput;
3332                                 false,                                                                                                  // bool sampleMaskTest;
3333                                 false,                                                                                                  // bool earlyAndLateTest;
3334                                 true,                                                                                                   // bool garbageAttachment;
3335                         }));
3336                 }
3337 #endif // CTS_USES_VULKANSC
3338
3339                 parentGroup->addChild(group.release());
3340         }
3341 }
3342
3343 }       // FragmentShadingRage
3344 }       // vkt