external/vulkancts/modules/vulkan/draw/vktDrawMultipleClearsWithinRenderPass.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2020 Google Inc.
   6  * Copyright (c) 2020 The Khronos Group Inc.
   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 multiple color or depth clears within a render pass
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktDrawMultipleClearsWithinRenderPass.hpp"
  26
  27 #include "vktTestGroupUtil.hpp"
  28 #include "vktTestCaseUtil.hpp"
  29 #include "vktDrawCreateInfoUtil.hpp"
  30 #include "vktDrawBufferObjectUtil.hpp"
  31 #include "vktDrawImageObjectUtil.hpp"
  32 #include "vkPrograms.hpp"
  33 #include "vkTypeUtil.hpp"
  34 #include "vkRefUtil.hpp"
  35 #include "vkCmdUtil.hpp"
  36 #include "vkBuilderUtil.hpp"
  37 #include "vkImageUtil.hpp"
  38 #include "vkQueryUtil.hpp"
  39 #include "tcuTextureUtil.hpp"
  40 #include "tcuCommandLine.hpp"
  41 #include "vktDrawTestCaseUtil.hpp"
  42
  43 #include "deStringUtil.hpp"
  44
  45 #include <cmath>
  46 #include <vector>
  47 #include <string>
  48 #include <sstream>
  49
  50 namespace vkt
  51 {
  52 namespace Draw
  53 {
  54 namespace
  55 {
  56 using namespace vk;
  57 using tcu::Vec4;
  58 using de::SharedPtr;
  59 using std::string;
  60 using std::abs;
  61 using std::vector;
  62 using std::ostringstream;
  63
  64 const deUint32                                          WIDTH                                   = 400;
  65 const deUint32                                          HEIGHT                                  = 300;
  66
  67 enum struct Topology
  68 {
  69         TRIANGLE_STRIP = 0,
  70         TRIANGLES,
  71         TRIANGLE
  72 };
  73
  74 const Topology                                          topologiesToTest[]              =
  75 {
  76         Topology::TRIANGLE_STRIP,
  77         Topology::TRIANGLES,
  78         Topology::TRIANGLE
  79 };
  80
  81 struct FormatPair
  82 {
  83         VkFormat colorFormat;
  84         VkFormat depthFormat;
  85 };
  86
  87 const FormatPair                                        formatsToTest[]                 =
  88 {
  89         { VK_FORMAT_R8G8B8A8_UNORM      , VK_FORMAT_UNDEFINED   },
  90         { VK_FORMAT_R8G8B8A8_SNORM      , VK_FORMAT_UNDEFINED   },
  91         { VK_FORMAT_UNDEFINED           , VK_FORMAT_D32_SFLOAT  },
  92         { VK_FORMAT_UNDEFINED           , VK_FORMAT_D16_UNORM   },
  93         { VK_FORMAT_R8G8B8A8_UNORM      , VK_FORMAT_D32_SFLOAT  },
  94         { VK_FORMAT_R8G8B8A8_UNORM      , VK_FORMAT_D16_UNORM   },
  95         { VK_FORMAT_R8G8B8A8_SNORM      , VK_FORMAT_D32_SFLOAT  },
  96         { VK_FORMAT_R8G8B8A8_SNORM      , VK_FORMAT_D16_UNORM   },
  97 };
  98
  99 const Vec4                                                      verticesTriangleStrip[] =
 100 {
 101         Vec4(-1.0f, -1.0f,      0.0f, 1.0f),    // 0 -- 2
 102         Vec4(-1.0f,      1.0f,  0.0f, 1.0f),    // |  / |
 103         Vec4( 1.0f, -1.0f,      0.0f, 1.0f),    // | /  |
 104         Vec4( 1.0f,      1.0f,  0.0f, 1.0f)             // 1 -- 3
 105 };
 106 const Vec4                                                      verticesTriangles[]             =
 107 {
 108         Vec4(-1.0f, -1.0f,      0.0f, 1.0f),    // 0 - 1
 109         Vec4(-1.0f,      1.0f,  0.0f, 1.0f),    // | /
 110         Vec4( 1.0f, -1.0f,      0.0f, 1.0f),    // 2
 111         Vec4( 1.0f, -1.0f,      0.0f, 1.0f),    //         4
 112         Vec4(-1.0f,      1.0f,  0.0f, 1.0f),    //       / |
 113         Vec4( 1.0f,      1.0f,  0.0f, 1.0f)             // 3 - 5
 114 };
 115 const Vec4                                                      verticesBigTriangle[]   =
 116 {
 117         Vec4(-1.0f, -1.0f,      0.0f, 1.0f),    // 0 - 2
 118         Vec4(-1.0f,      3.0f,  0.0f, 1.0f),    // | /
 119         Vec4( 3.0f, -1.0f,      0.0f, 1.0f),    // 1
 120 };
 121
 122 const deUint32                  TOPOLOGY_MAX_VERTICES_COUNT                     = 6;
 123 const deUint32                  TEST_MAX_STEPS_COUNT                            = 3;
 124
 125 struct Vertices
 126 {
 127         const char*                     testNameSuffix;
 128         VkPrimitiveTopology     topology;
 129         deUint32                        verticesCount;
 130         const Vec4*                     vertices;
 131 };
 132
 133 const Vertices                  verticesByTopology[]                            =
 134 {
 135         {
 136                 "_triangle_strip",
 137                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
 138                 DE_LENGTH_OF_ARRAY(verticesTriangleStrip),
 139                 verticesTriangleStrip
 140         },
 141         {
 142                 "_triangles",
 143                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 144                 DE_LENGTH_OF_ARRAY(verticesTriangles),
 145                 verticesTriangles
 146         },
 147         {
 148                 "_big_triangle",
 149                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 150                 DE_LENGTH_OF_ARRAY(verticesBigTriangle),
 151                 verticesBigTriangle
 152         }
 153 };
 154
 155 enum struct ClearOp
 156 {
 157         LOAD = 0,
 158         DRAW,
 159         CLEAR
 160 };
 161
 162 struct ClearStep
 163 {
 164         ClearOp                                 clearOp;
 165         Vec4                                    color;
 166         float                                   depth;
 167 };
 168
 169 struct TestParams
 170 {
 171         VkFormat                                colorFormat;
 172         VkFormat                                depthFormat;
 173         Topology                                topology;
 174         Vec4                                    expectedColor;
 175         float                                   colorEpsilon;
 176         float                                   expectedDepth;
 177         float                                   depthEpsilon;
 178         deUint32                                repeatCount;
 179         bool                                    enableBlend;
 180         const SharedGroupParams groupParams;
 181         vector<ClearStep>               steps;
 182 };
 183
 184 class MultipleClearsTest : public TestInstance
 185 {
 186 public:
 187                                                         MultipleClearsTest              (Context& context, const TestParams& params);
 188         virtual tcu::TestStatus iterate                                 (void);
 189
 190 private:
 191         void                                    preRenderCommands               (VkCommandBuffer cmdBuffer) const;
 192         void                                    beginLegacyRender               (VkCommandBuffer cmdBuffer) const;
 193         void                                    drawCommands                    (VkCommandBuffer cmdBuffer) const;
 194
 195 #ifndef CTS_USES_VULKANSC
 196         void                                    beginSecondaryCmdBuffer (VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags = 0u) const;
 197         void                                    beginDynamicRender              (VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags = 0u) const;
 198 #endif // CTS_USES_VULKANSC
 199
 200         SharedPtr<Image>                m_colorTargetImage;
 201         SharedPtr<Image>                m_depthTargetImage;
 202         Move<VkImageView>               m_colorTargetView;
 203         Move<VkImageView>               m_depthTargetView;
 204         SharedPtr<Buffer>               m_vertexBuffer;
 205         Move<VkRenderPass>              m_renderPass;
 206         Move<VkFramebuffer>             m_framebuffer;
 207         Move<VkPipelineLayout>  m_pipelineLayout;
 208         Move<VkPipeline>                m_pipeline;
 209
 210         const TestParams                m_params;
 211         Vec4                                    m_vertices[TOPOLOGY_MAX_VERTICES_COUNT * TEST_MAX_STEPS_COUNT];
 212 };
 213
 214 MultipleClearsTest::MultipleClearsTest (Context &context, const TestParams& params)
 215         : TestInstance(context)
 216         , m_params(params)
 217 {
 218         const DeviceInterface&          vk                                      = m_context.getDeviceInterface();
 219         const VkDevice                          device                          = m_context.getDevice();
 220         const deUint32                          queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 221         const bool                                      hasColor                        = m_params.colorFormat != VK_FORMAT_UNDEFINED;
 222         const bool                                      hasDepth                        = m_params.depthFormat != VK_FORMAT_UNDEFINED;
 223
 224         DescriptorSetLayoutBuilder      descriptorSetLayoutBuilder;
 225         // Vertex data
 226         const auto&                                     vertexData                      = verticesByTopology[(size_t)m_params.topology];
 227         {
 228                 DE_ASSERT(vertexData.verticesCount <= TOPOLOGY_MAX_VERTICES_COUNT);
 229                 const size_t                    verticesCount           = vertexData.verticesCount;
 230                 const VkDeviceSize              dataSize                        = verticesCount * sizeof(Vec4);
 231                 const VkDeviceSize              totalDataSize           = m_params.steps.size() * dataSize;
 232                 DE_ASSERT(totalDataSize <= sizeof(m_vertices));
 233
 234                 for(size_t i = 0; i < m_params.steps.size(); ++i)
 235                 {
 236                         const size_t start = i * verticesCount;
 237                         deMemcpy(&m_vertices[start], vertexData.vertices, static_cast<size_t>(dataSize));
 238                         for(size_t j = 0; j < verticesCount; ++j)
 239                                 m_vertices[start + j][2] = m_params.steps[i].depth;
 240                 }
 241                 m_vertexBuffer                                                          = Buffer::createAndAlloc(vk, device, BufferCreateInfo(totalDataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT),
 242                                                                                                                                                          m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
 243                 deMemcpy(m_vertexBuffer->getBoundMemory().getHostPtr(), m_vertices, static_cast<std::size_t>(totalDataSize));
 244                 flushMappedMemoryRange(vk, device, m_vertexBuffer->getBoundMemory().getMemory(), m_vertexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
 245         }
 246
 247         if (hasColor)
 248         {
 249                 const VkImageUsageFlags         targetImageUsageFlags           = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 250                 const ImageCreateInfo           targetImageCreateInfo           (VK_IMAGE_TYPE_2D, m_params.colorFormat, { WIDTH, HEIGHT, 1u }, 1u,     1u,     VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, targetImageUsageFlags);
 251                 m_colorTargetImage                                                                              = Image::createAndAlloc(vk, device, targetImageCreateInfo, m_context.getDefaultAllocator(), queueFamilyIndex);
 252                 const ImageViewCreateInfo       colorTargetViewInfo                     (m_colorTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_params.colorFormat);
 253                 m_colorTargetView                                                                               = createImageView(vk, device, &colorTargetViewInfo);
 254         }
 255
 256         if (hasDepth)
 257         {
 258                 const VkImageUsageFlags         depthImageUsageFlags            = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 259                 const ImageCreateInfo           depthImageCreateInfo            (VK_IMAGE_TYPE_2D, m_params.depthFormat, { WIDTH, HEIGHT, 1u }, 1u,     1u,     VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, depthImageUsageFlags);
 260                 m_depthTargetImage                                                                              = Image::createAndAlloc(vk, device, depthImageCreateInfo, m_context.getDefaultAllocator(), queueFamilyIndex);
 261                 const ImageViewCreateInfo       depthTargetViewInfo                     (m_depthTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_params.depthFormat);
 262                 m_depthTargetView                                                                               = createImageView(vk, device, &depthTargetViewInfo);
 263         }
 264
 265         // Render pass
 266         if (!m_params.groupParams->useDynamicRendering)
 267         {
 268                 RenderPassCreateInfo                    renderPassCreateInfo;
 269                 if (hasColor)
 270                 {
 271                         renderPassCreateInfo.addAttachment(AttachmentDescription(
 272                                  m_params.colorFormat,                                                          // format
 273                                  VK_SAMPLE_COUNT_1_BIT,                                                         // samples
 274                                  VK_ATTACHMENT_LOAD_OP_LOAD,                                            // loadOp
 275                                  VK_ATTACHMENT_STORE_OP_STORE,                                          // storeOp
 276                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                       // stencilLoadOp
 277                                  VK_ATTACHMENT_STORE_OP_DONT_CARE,                                      // stencilStoreOp
 278                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                      // initialLayout
 279                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));            // finalLayout
 280                 }
 281                 if (hasDepth)
 282                 {
 283                         renderPassCreateInfo.addAttachment(AttachmentDescription(
 284                                 m_params.depthFormat,                                                           // format
 285                                 VK_SAMPLE_COUNT_1_BIT,                                                          // samples
 286                                 VK_ATTACHMENT_LOAD_OP_LOAD,                                                     // loadOp
 287                                 VK_ATTACHMENT_STORE_OP_STORE,                                           // storeOp
 288                                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                        // stencilLoadOp
 289                                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                                       // stencilStoreOp
 290                                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,       // initialLayout
 291                                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));     // finalLayout
 292                 }
 293                 const VkAttachmentReference colorAttachmentReference            = hasColor ? makeAttachmentReference(0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) : AttachmentReference();
 294                 const VkAttachmentReference depthAttachmentReference            = hasDepth ? makeAttachmentReference(hasColor ? 1u : 0u, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) : AttachmentReference();
 295                 renderPassCreateInfo.addSubpass(SubpassDescription(
 296                         VK_PIPELINE_BIND_POINT_GRAPHICS,                                                // pipelineBindPoint
 297                         (VkSubpassDescriptionFlags)0,                                                   // flags
 298                         0u,                                                                                                             // inputAttachmentCount
 299                         DE_NULL,                                                                                                // inputAttachments
 300                         hasColor ? 1 : 0,                                                                               // colorAttachmentCount
 301                         hasColor ? &colorAttachmentReference : DE_NULL,                 // colorAttachments
 302                         DE_NULL,                                                                                                // resolveAttachments
 303                         depthAttachmentReference,                                                               // depthStencilAttachment
 304                         0u,                                                                                                             // preserveAttachmentCount
 305                         DE_NULL));                                                                                              // preserveAttachments
 306                 m_renderPass                                                                                            = createRenderPass(vk, device, &renderPassCreateInfo);
 307
 308                 std::vector<VkImageView> attachments;
 309                 if (hasColor)
 310                         attachments.push_back(*m_colorTargetView);
 311                 if (hasDepth)
 312                         attachments.push_back(*m_depthTargetView);
 313                 const FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, WIDTH, HEIGHT, 1);
 314                 m_framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
 315         }
 316
 317         // Vertex input
 318         const VkVertexInputBindingDescription           vertexInputBindingDescription   =
 319         {
 320                 0u,                                                                             // uint32_t                             binding;
 321                 sizeof(Vec4),                                                   // uint32_t                             stride;
 322                 VK_VERTEX_INPUT_RATE_VERTEX,                    // VkVertexInputRate    inputRate;
 323         };
 324
 325         const VkVertexInputAttributeDescription         vertexInputAttributeDescription =
 326         {
 327                 0u,                                                                             // uint32_t             location;
 328                 0u,                                                                             // uint32_t             binding;
 329                 VK_FORMAT_R32G32B32A32_SFLOAT,                  // VkFormat             format;
 330                 0u                                                                              // uint32_t             offset;
 331         };
 332
 333         const PipelineCreateInfo::VertexInputState      vertexInputState                                = PipelineCreateInfo::VertexInputState(1, &vertexInputBindingDescription,
 334                                                                                                                                                                                                                                            1, &vertexInputAttributeDescription);
 335
 336         // Graphics pipeline
 337         const Unique<VkShaderModule>                            vertexModule                                    (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
 338         const Unique<VkShaderModule>                            fragmentModule                                  (createShaderModule(vk, device, m_context.getBinaryCollection().get(hasColor ? "frag" : "frag_depthonly"), 0));
 339
 340         const VkPushConstantRange                                       pcRange                                                 = vk::VkPushConstantRange { VkShaderStageFlagBits::VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(ClearStep::color) };
 341         const PipelineLayoutCreateInfo                          pipelineLayoutCreateInfo                (0u, DE_NULL, 1u, &pcRange);
 342         m_pipelineLayout                                                                                                                        = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
 343
 344         const VkRect2D                                                          scissor                                                 = makeRect2D(WIDTH, HEIGHT);
 345         const VkViewport                                                        viewport                                                = makeViewport(WIDTH, HEIGHT);
 346
 347         const auto                                                                      vkCbAttachmentState                             = makePipelineColorBlendAttachmentState(
 348                 m_params.enableBlend ? VK_TRUE : VK_FALSE,      // VkBool32                                     blendEnable
 349                 VK_BLEND_FACTOR_SRC_ALPHA,                                      // VkBlendFactor                        srcColorBlendFactor
 350                 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,            // VkBlendFactor                        dstColorBlendFactor
 351                 VK_BLEND_OP_ADD,                                                        // VkBlendOp                            colorBlendOp
 352                 VK_BLEND_FACTOR_ZERO,                                           // VkBlendFactor                        srcAlphaBlendFactor
 353                 VK_BLEND_FACTOR_ONE,                                            // VkBlendFactor                        dstAlphaBlendFactor
 354                 VK_BLEND_OP_ADD,                                                        // VkBlendOp                            alphaBlendOp
 355                 VK_COLOR_COMPONENT_R_BIT |                                      // VkColorComponentFlags        colorWriteMask
 356                 VK_COLOR_COMPONENT_G_BIT |
 357                 VK_COLOR_COMPONENT_B_BIT |
 358                 VK_COLOR_COMPONENT_A_BIT);
 359         PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, (VkPipelineCreateFlags)0);
 360         pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vertexModule,       "main", VK_SHADER_STAGE_VERTEX_BIT));
 361         pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fragmentModule, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
 362         pipelineCreateInfo.addState (PipelineCreateInfo::VertexInputState       (vertexInputState));
 363         pipelineCreateInfo.addState (PipelineCreateInfo::InputAssemblerState(vertexData.topology));
 364         pipelineCreateInfo.addState (PipelineCreateInfo::ColorBlendState        (1, &vkCbAttachmentState));
 365         pipelineCreateInfo.addState (PipelineCreateInfo::ViewportState          (1, std::vector<VkViewport>(1, viewport), std::vector<VkRect2D>(1, scissor)));
 366         pipelineCreateInfo.addState (PipelineCreateInfo::DepthStencilState      (hasDepth, hasDepth, VK_COMPARE_OP_ALWAYS, VK_FALSE, VK_FALSE));
 367         pipelineCreateInfo.addState (PipelineCreateInfo::RasterizerState        ());
 368         pipelineCreateInfo.addState (PipelineCreateInfo::MultiSampleState       ());
 369
 370 #ifndef CTS_USES_VULKANSC
 371         vk::VkPipelineRenderingCreateInfoKHR renderingCreateInfo
 372         {
 373                 VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
 374                 DE_NULL,
 375                 0u,
 376                 hasColor,
 377                 (hasColor ? &m_params.colorFormat : DE_NULL),
 378                 m_params.depthFormat,
 379                 VK_FORMAT_UNDEFINED
 380         };
 381
 382         if (m_params.groupParams->useDynamicRendering)
 383                 pipelineCreateInfo.pNext = &renderingCreateInfo;
 384 #endif // CTS_USES_VULKANSC
 385
 386         m_pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
 387 }
 388
 389 void MultipleClearsTest::preRenderCommands(VkCommandBuffer cmdBuffer) const
 390 {
 391         const DeviceInterface& vk = m_context.getDeviceInterface();
 392         if (m_params.colorFormat)
 393                 initialTransitionColor2DImage(vk, cmdBuffer, m_colorTargetImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
 394         if (m_params.depthFormat)
 395                 initialTransitionDepth2DImage(vk, cmdBuffer, m_depthTargetImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
 396 }
 397
 398 void MultipleClearsTest::beginLegacyRender(VkCommandBuffer cmdBuffer) const
 399 {
 400         const DeviceInterface&  vk                      = m_context.getDeviceInterface();
 401         const VkRect2D                  renderArea      = makeRect2D(0, 0, WIDTH, HEIGHT);
 402
 403         if (!m_params.steps.empty() && m_params.steps[0].clearOp == ClearOp::LOAD)
 404                 beginRenderPass(vk, cmdBuffer, *m_renderPass, *m_framebuffer, renderArea, m_params.steps[0].color, m_params.steps[0].depth, 0);
 405         else
 406                 beginRenderPass(vk, cmdBuffer, *m_renderPass, *m_framebuffer, renderArea);
 407 }
 408
 409 void MultipleClearsTest::drawCommands(vk::VkCommandBuffer cmdBuffer) const
 410 {
 411         const DeviceInterface&  vk              = m_context.getDeviceInterface();
 412
 413         vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
 414         {
 415                 const VkDeviceSize      offset = 0;
 416                 const VkBuffer          buffer = m_vertexBuffer->object();
 417                 vk.cmdBindVertexBuffers(cmdBuffer, 0, 1, &buffer, &offset);
 418         }
 419
 420         for (deUint32 i = 0; i < m_params.repeatCount; ++i)
 421         for (size_t stepIndex = 0; stepIndex < m_params.steps.size(); ++stepIndex)
 422         {
 423                 const auto& step = m_params.steps[stepIndex];
 424
 425                 // ClearOp::LOAD only supported for first step
 426                 DE_ASSERT(stepIndex == 0 || step.clearOp != ClearOp::LOAD);
 427
 428                 const Vec4& color = step.color;
 429                 const float depth = step.depth;
 430
 431                 switch(step.clearOp)
 432                 {
 433                 case ClearOp::LOAD:
 434                         break;
 435                 case ClearOp::DRAW:
 436                         {
 437                                 const auto&             vertexData              = verticesByTopology[(size_t)m_params.topology];
 438                                 const deUint32  verticesCount   = vertexData.verticesCount;
 439                                 vk.cmdPushConstants(cmdBuffer, *m_pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(color), color.getPtr());
 440                                 vk.cmdDraw(cmdBuffer, verticesCount, 1, static_cast<deUint32>(verticesCount * stepIndex), 0);
 441                         }
 442                         break;
 443                 case ClearOp::CLEAR:
 444                         {
 445                                 vector<VkClearAttachment>       clearAttachments;
 446                                 if (m_params.colorFormat != VK_FORMAT_UNDEFINED)
 447                                 {
 448                                         const VkClearAttachment clearAttachment
 449                                         {
 450                                                 VK_IMAGE_ASPECT_COLOR_BIT,                                              // VkImageAspectFlags    aspectMask
 451                                                 static_cast<deUint32>(clearAttachments.size()), // uint32_t                              colorAttachment
 452                                                 makeClearValueColor(color)                                              // VkClearValue                  clearValue
 453                                         };
 454                                         clearAttachments.push_back(clearAttachment);
 455                                 }
 456                                 if (m_params.depthFormat != VK_FORMAT_UNDEFINED)
 457                                 {
 458                                         const VkClearAttachment clearAttachment
 459                                         {
 460                                                 VK_IMAGE_ASPECT_DEPTH_BIT,                                              // VkImageAspectFlags    aspectMask
 461                                                 static_cast<deUint32>(clearAttachments.size()), // uint32_t                              colorAttachment
 462                                                 makeClearValueDepthStencil(depth, 0)                    // VkClearValue                  clearValue
 463                                         };
 464                                         clearAttachments.push_back(clearAttachment);
 465                                 }
 466                                 const VkClearRect clearRect
 467                                 {
 468                                         makeRect2D(WIDTH, HEIGHT),                                                      // VkRect2D        rect
 469                                         0,                                                                                                      // uint32_t        baseArrayLayer
 470                                         1                                                                                                       // uint32_t        layerCount
 471                                 };
 472                                 vk.cmdClearAttachments(cmdBuffer, static_cast<deUint32>(clearAttachments.size()), clearAttachments.data(), 1, &clearRect);
 473                         }
 474                         break;
 475                 default:
 476                         break;
 477                 }
 478         }
 479 }
 480
 481 #ifndef CTS_USES_VULKANSC
 482 void MultipleClearsTest::beginSecondaryCmdBuffer(VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags) const
 483 {
 484         VkCommandBufferInheritanceRenderingInfoKHR inheritanceRenderingInfo
 485         {
 486                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR,                // VkStructureType                                      sType;
 487                 DE_NULL,                                                                                                                                // const void*                                          pNext;
 488                 renderingFlags,                                                                                                                 // VkRenderingFlagsKHR                          flags;
 489                 0u,                                                                                                                                             // uint32_t                                                     viewMask;
 490                 (m_params.colorFormat != VK_FORMAT_UNDEFINED),                                                  // uint32_t                                                     colorAttachmentCount;
 491                 &m_params.colorFormat,                                                                                                  // const VkFormat*                                      pColorAttachmentFormats;
 492                 m_params.depthFormat,                                                                                                   // VkFormat                                                     depthAttachmentFormat;
 493                 VK_FORMAT_UNDEFINED,                                                                                                    // VkFormat                                                     stencilAttachmentFormat;
 494                 VK_SAMPLE_COUNT_1_BIT,                                                                                                  // VkSampleCountFlagBits                        rasterizationSamples;
 495         };
 496
 497         const VkCommandBufferInheritanceInfo bufferInheritanceInfo = initVulkanStructure(&inheritanceRenderingInfo);
 498
 499         VkCommandBufferUsageFlags usageFlags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 500         if (!m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
 501                 usageFlags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
 502
 503         const VkCommandBufferBeginInfo commandBufBeginParams
 504         {
 505                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                                                    // VkStructureType                                      sType;
 506                 DE_NULL,                                                                                                                                // const void*                                          pNext;
 507                 usageFlags,                                                                                                                             // VkCommandBufferUsageFlags            flags;
 508                 &bufferInheritanceInfo
 509         };
 510
 511         const DeviceInterface& vk = m_context.getDeviceInterface();
 512         VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &commandBufBeginParams));
 513 }
 514
 515 void MultipleClearsTest::beginDynamicRender(VkCommandBuffer cmdBuffer, VkRenderingFlagsKHR renderingFlags) const
 516 {
 517         const DeviceInterface&  vk                      = m_context.getDeviceInterface();
 518         const VkRect2D                  renderArea      = makeRect2D(0, 0, WIDTH, HEIGHT);
 519
 520         VkClearValue clearColorValue = makeClearValueColor(tcu::Vec4(0.0f));
 521         VkClearValue clearDepthValue = makeClearValueDepthStencil(0.0f, 0u);
 522         if (!m_params.steps.empty() && m_params.steps[0].clearOp == ClearOp::LOAD)
 523         {
 524                 clearColorValue = makeClearValueColor(m_params.steps[0].color);
 525                 clearDepthValue = makeClearValueDepthStencil(m_params.steps[0].depth, 0u);
 526         }
 527
 528         vk::VkRenderingAttachmentInfoKHR colorAttachment
 529         {
 530                 vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,    // VkStructureType                                              sType;
 531                 DE_NULL,                                                                                                // const void*                                                  pNext;
 532                 *m_colorTargetView,                                                                             // VkImageView                                                  imageView;
 533                 vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                   // VkImageLayout                                                imageLayout;
 534                 vk::VK_RESOLVE_MODE_NONE,                                                               // VkResolveModeFlagBits                                resolveMode;
 535                 DE_NULL,                                                                                                // VkImageView                                                  resolveImageView;
 536                 vk::VK_IMAGE_LAYOUT_UNDEFINED,                                                  // VkImageLayout                                                resolveImageLayout;
 537                 vk::VK_ATTACHMENT_LOAD_OP_LOAD,                                                 // VkAttachmentLoadOp                                   loadOp;
 538                 vk::VK_ATTACHMENT_STORE_OP_STORE,                                               // VkAttachmentStoreOp                                  storeOp;
 539                 clearColorValue                                                                                 // VkClearValue                                                 clearValue;
 540         };
 541
 542         vk::VkRenderingAttachmentInfoKHR depthAttachment
 543         {
 544                 vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,    // VkStructureType                                              sType;
 545                 DE_NULL,                                                                                                // const void*                                                  pNext;
 546                 *m_depthTargetView,                                                                             // VkImageView                                                  imageView;
 547                 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,   // VkImageLayout                                                imageLayout;
 548                 vk::VK_RESOLVE_MODE_NONE,                                                               // VkResolveModeFlagBits                                resolveMode;
 549                 DE_NULL,                                                                                                // VkImageView                                                  resolveImageView;
 550                 vk::VK_IMAGE_LAYOUT_UNDEFINED,                                                  // VkImageLayout                                                resolveImageLayout;
 551                 vk::VK_ATTACHMENT_LOAD_OP_LOAD,                                                 // VkAttachmentLoadOp                                   loadOp;
 552                 vk::VK_ATTACHMENT_STORE_OP_STORE,                                               // VkAttachmentStoreOp                                  storeOp;
 553                 clearDepthValue                                                                                 // VkClearValue                                                 clearValue;
 554         };
 555
 556         const bool hasColor = m_params.colorFormat != VK_FORMAT_UNDEFINED;
 557         const bool hasDepth = m_params.depthFormat != VK_FORMAT_UNDEFINED;
 558
 559         vk::VkRenderingInfoKHR renderingInfo
 560         {
 561                 vk::VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
 562                 DE_NULL,
 563                 renderingFlags,                                                                                 // VkRenderingFlagsKHR                                  flags;
 564                 renderArea,                                                                                             // VkRect2D                                                             renderArea;
 565                 1u,                                                                                                             // deUint32                                                             layerCount;
 566                 0u,                                                                                                             // deUint32                                                             viewMask;
 567                 hasColor,                                                                                               // deUint32                                                             colorAttachmentCount;
 568                 (hasColor ? &colorAttachment : DE_NULL),                                // const VkRenderingAttachmentInfoKHR*  pColorAttachments;
 569                 (hasDepth ? &depthAttachment : DE_NULL),                                // const VkRenderingAttachmentInfoKHR*  pDepthAttachment;
 570                 DE_NULL,                                                                                                // const VkRenderingAttachmentInfoKHR*  pStencilAttachment;
 571         };
 572
 573         vk.cmdBeginRendering(cmdBuffer, &renderingInfo);
 574 }
 575 #endif // CTS_USES_VULKANSC
 576
 577 tcu::TestStatus MultipleClearsTest::iterate (void)
 578 {
 579         const DeviceInterface&                  vk                                      = m_context.getDeviceInterface();
 580         const VkDevice                                  device                          = m_context.getDevice();
 581         const VkQueue                                   queue                           = m_context.getUniversalQueue();
 582         const deUint32                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 583
 584         const CmdPoolCreateInfo                 cmdPoolCreateInfo       (queueFamilyIndex);
 585         const Unique<VkCommandPool>             cmdPool                         (createCommandPool(vk, device, &cmdPoolCreateInfo));
 586         const Unique<VkCommandBuffer>   cmdBuffer                       (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 587         Move<VkCommandBuffer>                   secCmdBuffer;
 588
 589         const bool                                              hasColor                        = m_params.colorFormat != VK_FORMAT_UNDEFINED;
 590         const bool                                              hasDepth                        = m_params.depthFormat != VK_FORMAT_UNDEFINED;
 591
 592 #ifndef CTS_USES_VULKANSC
 593         if (m_params.groupParams->useSecondaryCmdBuffer)
 594         {
 595                 secCmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
 596
 597                 // record secondary command buffer
 598                 if (m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
 599                 {
 600                         beginSecondaryCmdBuffer(*secCmdBuffer, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT);
 601                         beginDynamicRender(*secCmdBuffer);
 602                 }
 603                 else
 604                         beginSecondaryCmdBuffer(*secCmdBuffer);
 605
 606                 drawCommands(*secCmdBuffer);
 607
 608                 if (m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
 609                         endRendering(vk, *secCmdBuffer);
 610
 611                 endCommandBuffer(vk, *secCmdBuffer);
 612
 613                 // record primary command buffer
 614                 beginCommandBuffer(vk, *cmdBuffer, 0u);
 615                 preRenderCommands(*cmdBuffer);
 616
 617                 if (!m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
 618                         beginDynamicRender(*cmdBuffer, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
 619
 620                 vk.cmdExecuteCommands(*cmdBuffer, 1u, &*secCmdBuffer);
 621
 622                 if (!m_params.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
 623                         endRendering(vk, *cmdBuffer);
 624         }
 625         else if (m_params.groupParams->useDynamicRendering)
 626         {
 627                 beginCommandBuffer(vk, *cmdBuffer);
 628                 preRenderCommands(*cmdBuffer);
 629                 beginDynamicRender(*cmdBuffer);
 630                 drawCommands(*cmdBuffer);
 631                 endRendering(vk, *cmdBuffer);
 632         }
 633 #endif // CTS_USES_VULKANSC
 634
 635         if (!m_params.groupParams->useDynamicRendering)
 636         {
 637                 beginCommandBuffer(vk, *cmdBuffer);
 638                 preRenderCommands(*cmdBuffer);
 639                 beginLegacyRender(*cmdBuffer);
 640                 drawCommands(*cmdBuffer);
 641                 endRenderPass(vk, *cmdBuffer);
 642         }
 643
 644         if (hasDepth)
 645         {
 646                 const VkMemoryBarrier   memBarrier      = { VK_STRUCTURE_TYPE_MEMORY_BARRIER, DE_NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT };
 647                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
 648         }
 649         if (hasColor)
 650         {
 651                 const VkMemoryBarrier   memBarrier      = { VK_STRUCTURE_TYPE_MEMORY_BARRIER, DE_NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT };
 652                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
 653         }
 654
 655         if (hasColor)
 656                 transition2DImage(vk, *cmdBuffer, m_colorTargetImage->object(), VK_IMAGE_ASPECT_COLOR_BIT,
 657                                                   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 658                                                   VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT,
 659                                                   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_HOST_BIT);
 660         if (hasDepth)
 661                 transition2DImage(vk, *cmdBuffer, m_depthTargetImage->object(), VK_IMAGE_ASPECT_DEPTH_BIT,
 662                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 663                                                   VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT,
 664                                                   VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_HOST_BIT);
 665
 666         endCommandBuffer(vk, *cmdBuffer);
 667         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
 668
 669         VK_CHECK(vk.queueWaitIdle(queue));
 670
 671         if (hasColor)
 672         {
 673                 const auto              resultImage     = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, { 0, 0, 0 }, WIDTH, HEIGHT, VK_IMAGE_ASPECT_COLOR_BIT);
 674
 675 #ifdef CTS_USES_VULKANSC
 676                 if (m_context.getTestContext().getCommandLine().isSubProcess())
 677 #endif // CTS_USES_VULKANSC
 678                 {
 679                         for(int z = 0; z < resultImage.getDepth(); ++z)
 680                         for(int y = 0; y < resultImage.getHeight(); ++y)
 681                         for(int x = 0; x < resultImage.getWidth(); ++x)
 682                         {
 683                                 const Vec4      difference      = m_params.expectedColor - resultImage.getPixel(x,y,z);
 684                                 if (abs(difference.x()) >= m_params.colorEpsilon || abs(difference.y()) >= m_params.colorEpsilon || abs(difference.z()) >= m_params.colorEpsilon)
 685                                 {
 686                                         ostringstream msg;
 687                                         msg << "Color value mismatch, expected: " << m_params.expectedColor << ", got: " << resultImage.getPixel(x,y,z) << " at " << "(" << x << ", " << y << ", " << z << ")";
 688                                         return tcu::TestStatus::fail(msg.str());
 689                                 }
 690                         }
 691                 }
 692         }
 693         if (hasDepth)
 694         {
 695                 const auto              resultImage     = m_depthTargetImage->readSurface(queue, m_context.getDefaultAllocator(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, { 0, 0, 0 }, WIDTH, HEIGHT, VK_IMAGE_ASPECT_DEPTH_BIT);
 696
 697 #ifdef CTS_USES_VULKANSC
 698                 if (m_context.getTestContext().getCommandLine().isSubProcess())
 699 #endif // CTS_USES_VULKANSC
 700                 {
 701                         for(int z = 0; z < resultImage.getDepth(); ++z)
 702                         for(int y = 0; y < resultImage.getHeight(); ++y)
 703                         for(int x = 0; x < resultImage.getWidth(); ++x)
 704                         {
 705                                 const float     difference      = m_params.expectedDepth - resultImage.getPixDepth(x,y,z);
 706                                 if (abs(difference) >= m_params.depthEpsilon)
 707                                 {
 708                                         ostringstream msg;
 709                                         msg << "Depth value mismatch, expected: " << m_params.expectedDepth << ", got: " << resultImage.getPixDepth(x,y,z) << " at " << "(" << x << ", " << y << ", " << z << ")";
 710                                         return tcu::TestStatus::fail(msg.str());
 711                                 }
 712                         }
 713                 }
 714         }
 715         return tcu::TestStatus::pass("Pass");
 716 }
 717
 718 class MultipleClearsWithinRenderPassTest : public TestCase
 719 {
 720 public:
 721         MultipleClearsWithinRenderPassTest (tcu::TestContext& testCtx, const string& name, const string& description, const TestParams& params)
 722                 : TestCase(testCtx, name, description)
 723                 , m_params(params)
 724         {
 725                 DE_ASSERT(m_params.steps.size() <= static_cast<size_t>(TEST_MAX_STEPS_COUNT));
 726         }
 727
 728         virtual void initPrograms (SourceCollections& programCollection) const
 729         {
 730                 {
 731                         ostringstream src;
 732                         src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 733                                 << "\n"
 734                                 << "layout(location = 0) in vec4 in_position;\n"
 735                                 << "\n"
 736                                 << "out gl_PerVertex {\n"
 737                                 << "    vec4  gl_Position;\n"
 738                                 << "};\n"
 739                                 << "\n"
 740                                 << "void main(void)\n"
 741                                 << "{\n"
 742                                 << "    gl_Position = in_position;\n"
 743                                 << "}\n";
 744                         programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
 745                 }
 746                 {
 747                         ostringstream src;
 748                         src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 749                                 << "\n"
 750                                 << "layout(push_constant) uniform Color { vec4 color; } u_color;\n"
 751                                 << "layout(location = 0) out vec4 out_color;\n"
 752                                 << "\n"
 753                                 << "void main(void)\n"
 754                                 << "{\n"
 755                                 << "    out_color = u_color.color;\n"
 756                                 << "}\n";
 757                         programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
 758                 }
 759                 {
 760                         ostringstream src;
 761                         src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
 762                                 << "\n"
 763                                 << "layout(push_constant) uniform Color { vec4 color; } u_color;\n"
 764                                 << "\n"
 765                                 << "void main(void)\n"
 766                                 << "{\n"
 767                                 << "}\n";
 768                         programCollection.glslSources.add("frag_depthonly") << glu::FragmentSource(src.str());
 769                 }
 770         }
 771
 772         virtual void checkSupport (Context& context) const
 773         {
 774                 VkImageFormatProperties imageFormatProperties;
 775                 const auto&     vki     = context.getInstanceInterface();
 776                 const auto&     vkd     = context.getPhysicalDevice();
 777                 if (m_params.colorFormat != VK_FORMAT_UNDEFINED)
 778                 {
 779                         const auto      colorUsage      = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 780                         if (vki.getPhysicalDeviceImageFormatProperties(vkd, m_params.colorFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, colorUsage, 0u, &imageFormatProperties) != VK_SUCCESS)
 781                                 TCU_THROW(NotSupportedError, "Color format not supported");
 782                 }
 783                 if (m_params.depthFormat != VK_FORMAT_UNDEFINED)
 784                 {
 785                         const auto      depthUsage      = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 786                         if (vki.getPhysicalDeviceImageFormatProperties(vkd, m_params.depthFormat, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, depthUsage, 0u, &imageFormatProperties) != VK_SUCCESS)
 787                                 TCU_THROW(NotSupportedError, "Depth format not supported");
 788                 }
 789
 790                 if (m_params.groupParams->useDynamicRendering)
 791                         context.requireDeviceFunctionality("VK_KHR_dynamic_rendering");
 792         }
 793
 794         virtual TestInstance* createInstance (Context& context) const
 795         {
 796                 return new MultipleClearsTest(context, m_params);
 797         }
 798
 799 private:
 800         const TestParams        m_params;
 801 };
 802
 803 }       // anonymous
 804
 805 MultipleClearsWithinRenderPassTests::MultipleClearsWithinRenderPassTests (tcu::TestContext &testCtx, const SharedGroupParams groupParams)
 806         : TestCaseGroup (testCtx, "multiple_clears_within_render_pass", "Tests for multiple clears within render pass")
 807         , m_groupParams (groupParams)
 808 {
 809 }
 810
 811 MultipleClearsWithinRenderPassTests::~MultipleClearsWithinRenderPassTests ()
 812 {
 813 }
 814
 815 void MultipleClearsWithinRenderPassTests::init ()
 816 {
 817         for(const auto &formatPair : formatsToTest)
 818         {
 819                 ostringstream                   formatSuffix;
 820                 if (formatPair.colorFormat != VK_FORMAT_UNDEFINED)
 821                         formatSuffix << "_c" << de::toLower(string(getFormatName(formatPair.colorFormat)).substr(9));
 822                 if (formatPair.depthFormat != VK_FORMAT_UNDEFINED)
 823                         formatSuffix << "_d" << de::toLower(string(getFormatName(formatPair.depthFormat)).substr(9));
 824                 for(const auto &topology : topologiesToTest)
 825                 {
 826                         // reduce number of tests for dynamic rendering cases where secondary command buffer is used
 827                         if (m_groupParams->useSecondaryCmdBuffer && (topology != Topology::TRIANGLE_STRIP))
 828                                 continue;
 829
 830                         const string    testNameSuffix  = formatSuffix.str() + verticesByTopology[(deUint32)topology].testNameSuffix;
 831                         {
 832                                 const TestParams params
 833                                 {
 834                                         formatPair.colorFormat,                 // VkFormat                             colorFormat;
 835                                         formatPair.depthFormat,                 // VkFormat                             depthFormat;
 836                                         topology,                                               // Topology                             topology;
 837                                         Vec4(0.0f, 0.5f, 0.5f, 1.0f),   // Vec4                                 expectedColor;
 838                                         0.01f,                                                  // float                                colorEpsilon;
 839                                         0.9f,                                                   // float                                expectedDepth;
 840                                         0.01f,                                                  // float                                depthEpsilon;
 841                                         1u,                                                             // deUint32                             repeatCount;
 842                                         true,                                                   // bool                                 enableBlend;
 843                                         m_groupParams,                                  // SharedGroupParams    groupParams;
 844                                         {                                                               // vector<ClearStep>    steps;
 845                                                 { ClearOp::LOAD         , Vec4(1.0f, 0.0f, 0.0f, 1.0f)  , 0.7f },
 846                                                 { ClearOp::CLEAR        , Vec4(0.0f, 1.0f, 0.0f, 1.0f)  , 0.3f },
 847                                                 { ClearOp::DRAW         , Vec4(0.0f, 0.0f, 1.0f, 0.5f)  , 0.9f }
 848                                         }
 849                                 };
 850                                 addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "load_clear_draw" + testNameSuffix, "Multiple clears within same render pass, methods: load, clear, draw", params));
 851                         }
 852                         {
 853                                 const TestParams params
 854                                 {
 855                                         formatPair.colorFormat,                 // VkFormat                             format;
 856                                         formatPair.depthFormat,                 // VkFormat                             depthFormat;
 857                                         topology,                                               // Topology                             topology;
 858                                         Vec4(0.0f, 0.5f, 0.5f, 1.0f),   // Vec4                                 expectedColor;
 859                                         0.01f,                                                  // float                                colorEpsilon;
 860                                         0.9f,                                                   // float                                expectedDepth;
 861                                         0.01f,                                                  // float                                depthEpsilon;
 862                                         1u,                                                             // deUint32                             repeatCount;
 863                                         true,                                                   // bool                                 enableBlend;
 864                                         m_groupParams,                                  // SharedGroupParams    groupParams;
 865                                         {                                                               // vector<ClearStep>    steps;
 866                                                 { ClearOp::DRAW         , Vec4(1.0f, 0.0f, 0.0f, 1.0f)  , 0.7f },
 867                                                 { ClearOp::CLEAR        , Vec4(0.0f, 1.0f, 0.0f, 1.0f)  , 0.3f },
 868                                                 { ClearOp::DRAW         , Vec4(0.0f, 0.0f, 1.0f, 0.5f)  , 0.9f }
 869                                         }
 870                                 };
 871                                 addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "draw_clear_draw" + testNameSuffix, "Multiple clears within same render pass, methods: draw, clear, draw", params));
 872                         }
 873                         {
 874                                 const TestParams params
 875                                 {
 876                                         formatPair.colorFormat,                 // VkFormat                             format;
 877                                         formatPair.depthFormat,                 // VkFormat                             depthFormat;
 878                                         topology,                                               // Topology                             topology;
 879                                         Vec4(0.0f, 0.5f, 0.5f, 1.0f),   // Vec4                                 expectedColor;
 880                                         0.01f,                                                  // float                                colorEpsilon;
 881                                         0.9f,                                                   // float                                expectedDepth;
 882                                         0.01f,                                                  // float                                depthEpsilon;
 883                                         1u,                                                             // deUint32                             repeatCount;
 884                                         true,                                                   // bool                                 enableBlend;
 885                                         m_groupParams,                                  // SharedGroupParams    groupParams;
 886                                         {                                                               // vector<ClearStep>    steps;
 887                                                 { ClearOp::CLEAR        , Vec4(1.0f, 0.0f, 0.0f, 1.0f)  , 0.7f },
 888                                                 { ClearOp::CLEAR        , Vec4(0.0f, 1.0f, 0.0f, 1.0f)  , 0.3f },
 889                                                 { ClearOp::DRAW         , Vec4(0.0f, 0.0f, 1.0f, 0.5f)  , 0.9f }
 890                                         }
 891                                 };
 892                                 addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "clear_clear_draw" + testNameSuffix, "Multiple clears within same render pass, methods: clear, clear, draw", params));
 893                         }
 894                         {
 895                                 const TestParams params
 896                                 {
 897                                         formatPair.colorFormat,                 // VkFormat                             format;
 898                                         formatPair.depthFormat,                 // VkFormat                             depthFormat;
 899                                         topology,                                               // Topology                             topology;
 900                                         Vec4(0.0f, 1.0f, 0.0f, 1.0f),   // Vec4                                 expectedColor;
 901                                         0.01f,                                                  // float                                colorEpsilon;
 902                                         0.9f,                                                   // float                                expectedDepth;
 903                                         0.01f,                                                  // float                                depthEpsilon;
 904                                         1u,                                                             // deUint32                             repeatCount;
 905                                         false,                                                  // bool                                 enableBlend;
 906                                         m_groupParams,                                  // SharedGroupParams    groupParams;
 907                                         {                                                               // vector<ClearStep>    steps;
 908                                                 { ClearOp::LOAD         , Vec4(1.0f, 0.0f, 0.0f, 1.0f)  , 0.3f },
 909                                                 { ClearOp::CLEAR        , Vec4(0.0f, 1.0f, 0.0f, 1.0f)  , 0.9f }
 910                                         }
 911                                 };
 912                                 addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "load_clear" + testNameSuffix, "Multiple clears within same render pass, methods: load, clear", params));
 913                         }
 914                         {
 915                                 const TestParams params
 916                                 {
 917                                         formatPair.colorFormat,                 // VkFormat                             format;
 918                                         formatPair.depthFormat,                 // VkFormat                             depthFormat;
 919                                         topology,                                               // Topology                             topology;
 920                                         Vec4(0.0f, 1.0f, 0.0f, 1.0f),   // Vec4                                 expectedColor;
 921                                         0.01f,                                                  // float                                colorEpsilon;
 922                                         0.9f,                                                   // float                                expectedDepth;
 923                                         0.01f,                                                  // float                                depthEpsilon;
 924                                         1u,                                                             // deUint32                             repeatCount;
 925                                         false,                                                  // bool                                 enableBlend;
 926                                         m_groupParams,                                  // SharedGroupParams    groupParams;
 927                                         {                                                               // vector<ClearStep>    steps;
 928                                                 { ClearOp::DRAW         , Vec4(1.0f, 0.0f, 0.0f, 1.0f)  , 0.3f },
 929                                                 { ClearOp::CLEAR        , Vec4(0.0f, 1.0f, 0.0f, 1.0f)  , 0.9f }
 930                                         }
 931                                 };
 932                                 addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "draw_clear" + testNameSuffix, "Multiple clears within same render pass, methods: draw, clear", params));
 933                         }
 934                         {
 935                                 const TestParams params
 936                                 {
 937                                         formatPair.colorFormat,                 // VkFormat                             format;
 938                                         formatPair.depthFormat,                 // VkFormat                             depthFormat;
 939                                         topology,                                               // Topology                             topology;
 940                                         Vec4(0.0f, 1.0f, 0.0f, 1.0f),   // Vec4                                 expectedColor;
 941                                         0.01f,                                                  // float                                colorEpsilon;
 942                                         0.9f,                                                   // float                                expectedDepth;
 943                                         0.01f,                                                  // float                                depthEpsilon;
 944                                         1u,                                                             // deUint32                             repeatCount;
 945                                         false,                                                  // bool                                 enableBlend;
 946                                         m_groupParams,                                  // SharedGroupParams    groupParams;
 947                                         {                                                               // vector<ClearStep>    steps;
 948                                                 { ClearOp::CLEAR        , Vec4(1.0f, 0.0f, 0.0f, 1.0f)  , 0.3f },
 949                                                 { ClearOp::CLEAR        , Vec4(0.0f, 1.0f, 0.0f, 1.0f)  , 0.9f }
 950                                         }
 951                                 };
 952                                 addChild(new MultipleClearsWithinRenderPassTest(m_testCtx, "clear_clear" + testNameSuffix, "Multiple clears within same render pass, methods: clear, clear", params));
 953                         }
 954                 }
 955         }
 956 }
 957 }       // Draw
 958 }       // vkt