external/vulkancts/modules/vulkan/renderpass/vktRenderPassTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 Google Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief RenderPass tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktRenderPassTests.hpp"
  25
  26 #include "vktRenderPassMultisampleTests.hpp"
  27 #include "vktRenderPassMultisampleResolveTests.hpp"
  28
  29 #include "vktTestCaseUtil.hpp"
  30 #include "vktTestGroupUtil.hpp"
  31
  32 #include "vkDefs.hpp"
  33 #include "vkDeviceUtil.hpp"
  34 #include "vkImageUtil.hpp"
  35 #include "vkMemUtil.hpp"
  36 #include "vkPlatform.hpp"
  37 #include "vkPrograms.hpp"
  38 #include "vkQueryUtil.hpp"
  39 #include "vkRef.hpp"
  40 #include "vkRefUtil.hpp"
  41 #include "vkStrUtil.hpp"
  42 #include "vkTypeUtil.hpp"
  43
  44 #include "tcuFloat.hpp"
  45 #include "tcuFormatUtil.hpp"
  46 #include "tcuMaybe.hpp"
  47 #include "tcuResultCollector.hpp"
  48 #include "tcuTestLog.hpp"
  49 #include "tcuTextureUtil.hpp"
  50 #include "tcuVectorUtil.hpp"
  51
  52 #include "deRandom.hpp"
  53 #include "deSTLUtil.hpp"
  54 #include "deSharedPtr.hpp"
  55 #include "deStringUtil.hpp"
  56 #include "deUniquePtr.hpp"
  57
  58 #include <limits>
  59 #include <set>
  60 #include <string>
  61 #include <vector>
  62
  63 using namespace vk;
  64
  65 using tcu::BVec4;
  66 using tcu::IVec2;
  67 using tcu::IVec4;
  68 using tcu::UVec2;
  69 using tcu::UVec4;
  70 using tcu::Vec2;
  71 using tcu::Vec4;
  72
  73 using tcu::Maybe;
  74 using tcu::just;
  75 using tcu::nothing;
  76
  77 using tcu::ConstPixelBufferAccess;
  78 using tcu::PixelBufferAccess;
  79
  80 using tcu::TestLog;
  81
  82 using de::UniquePtr;
  83
  84 using std::pair;
  85 using std::set;
  86 using std::string;
  87 using std::vector;
  88
  89 namespace vkt
  90 {
  91 namespace
  92 {
  93 enum AllocationKind
  94 {
  95         ALLOCATION_KIND_SUBALLOCATED,
  96         ALLOCATION_KIND_DEDICATED,
  97 };
  98
  99 de::MovePtr<Allocation> allocateBuffer (const InstanceInterface&        vki,
 100                                                                                 const DeviceInterface&          vkd,
 101                                                                                 const VkPhysicalDevice&         physDevice,
 102                                                                                 const VkDevice                          device,
 103                                                                                 const VkBuffer&                         buffer,
 104                                                                                 const MemoryRequirement         requirement,
 105                                                                                 Allocator&                                      allocator,
 106                                                                                 AllocationKind                          allocationKind)
 107 {
 108         switch (allocationKind)
 109         {
 110                 case ALLOCATION_KIND_SUBALLOCATED:
 111                 {
 112                         const VkMemoryRequirements      memoryRequirements      = getBufferMemoryRequirements(vkd, device, buffer);
 113
 114                         return allocator.allocate(memoryRequirements, requirement);
 115                 }
 116
 117                 case ALLOCATION_KIND_DEDICATED:
 118                 {
 119                         return allocateDedicated(vki, vkd, physDevice, device, buffer, requirement);
 120                 }
 121
 122                 default:
 123                 {
 124                         TCU_THROW(InternalError, "Invalid allocation kind");
 125                 }
 126         }
 127 }
 128
 129 de::MovePtr<Allocation> allocateImage (const InstanceInterface&         vki,
 130                                                                            const DeviceInterface&               vkd,
 131                                                                            const VkPhysicalDevice&              physDevice,
 132                                                                            const VkDevice                               device,
 133                                                                            const VkImage&                               image,
 134                                                                            const MemoryRequirement              requirement,
 135                                                                            Allocator&                                   allocator,
 136                                                                            AllocationKind                               allocationKind)
 137 {
 138         switch (allocationKind)
 139         {
 140                 case ALLOCATION_KIND_SUBALLOCATED:
 141                 {
 142                         const VkMemoryRequirements      memoryRequirements      = getImageMemoryRequirements(vkd, device, image);
 143
 144                         return allocator.allocate(memoryRequirements, requirement);
 145                 }
 146
 147                 case ALLOCATION_KIND_DEDICATED:
 148                 {
 149                         return allocateDedicated(vki, vkd, physDevice, device, image, requirement);
 150                 }
 151
 152                 default:
 153                 {
 154                         TCU_THROW(InternalError, "Invalid allocation kind");
 155                 }
 156         }
 157 }
 158
 159 enum BoolOp
 160 {
 161         BOOLOP_AND,
 162         BOOLOP_OR,
 163         BOOLOP_EQ,
 164         BOOLOP_NEQ
 165 };
 166
 167 const char* boolOpToString (BoolOp op)
 168 {
 169         switch (op)
 170         {
 171                 case BOOLOP_OR:
 172                         return "||";
 173
 174                 case BOOLOP_AND:
 175                         return "&&";
 176
 177                 case BOOLOP_EQ:
 178                         return "==";
 179
 180                 case BOOLOP_NEQ:
 181                         return "!=";
 182
 183                 default:
 184                         DE_FATAL("Unknown boolean operation.");
 185                         return DE_NULL;
 186         }
 187 }
 188
 189 bool performBoolOp (BoolOp op, bool a, bool b)
 190 {
 191         switch (op)
 192         {
 193                 case BOOLOP_OR:
 194                         return a || b;
 195
 196                 case BOOLOP_AND:
 197                         return a && b;
 198
 199                 case BOOLOP_EQ:
 200                         return a == b;
 201
 202                 case BOOLOP_NEQ:
 203                         return a != b;
 204
 205                 default:
 206                         DE_FATAL("Unknown boolean operation.");
 207                         return false;
 208         }
 209 }
 210
 211 BoolOp boolOpFromIndex (size_t index)
 212 {
 213         const BoolOp ops[] =
 214         {
 215                 BOOLOP_OR,
 216                 BOOLOP_AND,
 217                 BOOLOP_EQ,
 218                 BOOLOP_NEQ
 219         };
 220
 221         return ops[index % DE_LENGTH_OF_ARRAY(ops)];
 222 }
 223
 224 Move<VkFramebuffer> createFramebuffer (const DeviceInterface&   vk,
 225                                                                            VkDevice                                     device,
 226                                                                            VkFramebufferCreateFlags     pCreateInfo_flags,
 227                                                                            VkRenderPass                         pCreateInfo_renderPass,
 228                                                                            deUint32                                     pCreateInfo_attachmentCount,
 229                                                                            const VkImageView*           pCreateInfo_pAttachments,
 230                                                                            deUint32                                     pCreateInfo_width,
 231                                                                            deUint32                                     pCreateInfo_height,
 232                                                                            deUint32                                     pCreateInfo_layers)
 233 {
 234         const VkFramebufferCreateInfo pCreateInfo =
 235         {
 236                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
 237                 DE_NULL,
 238                 pCreateInfo_flags,
 239                 pCreateInfo_renderPass,
 240                 pCreateInfo_attachmentCount,
 241                 pCreateInfo_pAttachments,
 242                 pCreateInfo_width,
 243                 pCreateInfo_height,
 244                 pCreateInfo_layers,
 245         };
 246         return createFramebuffer(vk, device, &pCreateInfo);
 247 }
 248
 249 Move<VkImage> createImage (const DeviceInterface&       vk,
 250                                                    VkDevice                                     device,
 251                                                    VkImageCreateFlags           pCreateInfo_flags,
 252                                                    VkImageType                          pCreateInfo_imageType,
 253                                                    VkFormat                                     pCreateInfo_format,
 254                                                    VkExtent3D                           pCreateInfo_extent,
 255                                                    deUint32                                     pCreateInfo_mipLevels,
 256                                                    deUint32                                     pCreateInfo_arrayLayers,
 257                                                    VkSampleCountFlagBits        pCreateInfo_samples,
 258                                                    VkImageTiling                        pCreateInfo_tiling,
 259                                                    VkImageUsageFlags            pCreateInfo_usage,
 260                                                    VkSharingMode                        pCreateInfo_sharingMode,
 261                                                    deUint32                                     pCreateInfo_queueFamilyCount,
 262                                                    const deUint32*                      pCreateInfo_pQueueFamilyIndices,
 263                                                    VkImageLayout                        pCreateInfo_initialLayout)
 264 {
 265         const VkImageCreateInfo pCreateInfo =
 266         {
 267                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
 268                 DE_NULL,
 269                 pCreateInfo_flags,
 270                 pCreateInfo_imageType,
 271                 pCreateInfo_format,
 272                 pCreateInfo_extent,
 273                 pCreateInfo_mipLevels,
 274                 pCreateInfo_arrayLayers,
 275                 pCreateInfo_samples,
 276                 pCreateInfo_tiling,
 277                 pCreateInfo_usage,
 278                 pCreateInfo_sharingMode,
 279                 pCreateInfo_queueFamilyCount,
 280                 pCreateInfo_pQueueFamilyIndices,
 281                 pCreateInfo_initialLayout
 282         };
 283         return createImage(vk, device, &pCreateInfo);
 284 }
 285
 286 void bindBufferMemory (const DeviceInterface& vk, VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset)
 287 {
 288         VK_CHECK(vk.bindBufferMemory(device, buffer, mem, memOffset));
 289 }
 290
 291 void bindImageMemory (const DeviceInterface& vk, VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset)
 292 {
 293         VK_CHECK(vk.bindImageMemory(device, image, mem, memOffset));
 294 }
 295
 296 Move<VkImageView> createImageView (const DeviceInterface&       vk,
 297                                                                         VkDevice                                device,
 298                                                                         VkImageViewCreateFlags  pCreateInfo_flags,
 299                                                                         VkImage                                 pCreateInfo_image,
 300                                                                         VkImageViewType                 pCreateInfo_viewType,
 301                                                                         VkFormat                                pCreateInfo_format,
 302                                                                         VkComponentMapping              pCreateInfo_components,
 303                                                                         VkImageSubresourceRange pCreateInfo_subresourceRange)
 304 {
 305         const VkImageViewCreateInfo pCreateInfo =
 306         {
 307                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 308                 DE_NULL,
 309                 pCreateInfo_flags,
 310                 pCreateInfo_image,
 311                 pCreateInfo_viewType,
 312                 pCreateInfo_format,
 313                 pCreateInfo_components,
 314                 pCreateInfo_subresourceRange,
 315         };
 316         return createImageView(vk, device, &pCreateInfo);
 317 }
 318
 319 Move<VkBuffer> createBuffer (const DeviceInterface&     vk,
 320                                                          VkDevice                               device,
 321                                                          VkBufferCreateFlags    pCreateInfo_flags,
 322                                                          VkDeviceSize                   pCreateInfo_size,
 323                                                          VkBufferUsageFlags             pCreateInfo_usage,
 324                                                          VkSharingMode                  pCreateInfo_sharingMode,
 325                                                          deUint32                               pCreateInfo_queueFamilyCount,
 326                                                          const deUint32*                pCreateInfo_pQueueFamilyIndices)
 327 {
 328         const VkBufferCreateInfo pCreateInfo =
 329         {
 330                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
 331                 DE_NULL,
 332                 pCreateInfo_flags,
 333                 pCreateInfo_size,
 334                 pCreateInfo_usage,
 335                 pCreateInfo_sharingMode,
 336                 pCreateInfo_queueFamilyCount,
 337                 pCreateInfo_pQueueFamilyIndices,
 338         };
 339         return createBuffer(vk, device, &pCreateInfo);
 340 }
 341
 342 void cmdBeginRenderPass (const DeviceInterface& vk,
 343                                                  VkCommandBuffer                cmdBuffer,
 344                                                  VkRenderPass                   pRenderPassBegin_renderPass,
 345                                                  VkFramebuffer                  pRenderPassBegin_framebuffer,
 346                                                  VkRect2D                               pRenderPassBegin_renderArea,
 347                                                  deUint32                               pRenderPassBegin_clearValueCount,
 348                                                  const VkClearValue*    pRenderPassBegin_pAttachmentClearValues,
 349                                                  VkSubpassContents              contents)
 350 {
 351         const VkRenderPassBeginInfo pRenderPassBegin =
 352         {
 353                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
 354                 DE_NULL,
 355                 pRenderPassBegin_renderPass,
 356                 pRenderPassBegin_framebuffer,
 357                 pRenderPassBegin_renderArea,
 358                 pRenderPassBegin_clearValueCount,
 359                 pRenderPassBegin_pAttachmentClearValues,
 360         };
 361         vk.cmdBeginRenderPass(cmdBuffer, &pRenderPassBegin, contents);
 362 }
 363
 364 void beginCommandBuffer (const DeviceInterface&                 vk,
 365                                                  VkCommandBuffer                                cmdBuffer,
 366                                                  VkCommandBufferUsageFlags              pBeginInfo_flags,
 367                                                  VkRenderPass                                   pInheritanceInfo_renderPass,
 368                                                  deUint32                                               pInheritanceInfo_subpass,
 369                                                  VkFramebuffer                                  pInheritanceInfo_framebuffer,
 370                                                  VkBool32                                               pInheritanceInfo_occlusionQueryEnable,
 371                                                  VkQueryControlFlags                    pInheritanceInfo_queryFlags,
 372                                                  VkQueryPipelineStatisticFlags  pInheritanceInfo_pipelineStatistics)
 373 {
 374         const VkCommandBufferInheritanceInfo pInheritanceInfo =
 375         {
 376                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
 377                 DE_NULL,
 378                 pInheritanceInfo_renderPass,
 379                 pInheritanceInfo_subpass,
 380                 pInheritanceInfo_framebuffer,
 381                 pInheritanceInfo_occlusionQueryEnable,
 382                 pInheritanceInfo_queryFlags,
 383                 pInheritanceInfo_pipelineStatistics,
 384         };
 385         const VkCommandBufferBeginInfo pBeginInfo =
 386         {
 387                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 388                 DE_NULL,
 389                 pBeginInfo_flags,
 390                 &pInheritanceInfo,
 391         };
 392         VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &pBeginInfo));
 393 }
 394
 395 void endCommandBuffer (const DeviceInterface& vk, VkCommandBuffer cmdBuffer)
 396 {
 397         VK_CHECK(vk.endCommandBuffer(cmdBuffer));
 398 }
 399
 400 void queueSubmit (const DeviceInterface& vk, VkQueue queue, deUint32 cmdBufferCount, const VkCommandBuffer* pCmdBuffers, VkFence fence)
 401 {
 402         const VkSubmitInfo submitInfo =
 403         {
 404                 VK_STRUCTURE_TYPE_SUBMIT_INFO,
 405                 DE_NULL,
 406                 0u,                                                             // waitSemaphoreCount
 407                 (const VkSemaphore*)DE_NULL,    // pWaitSemaphores
 408                 (const VkPipelineStageFlags*)DE_NULL,
 409                 cmdBufferCount,                                 // commandBufferCount
 410                 pCmdBuffers,
 411                 0u,                                                             // signalSemaphoreCount
 412                 (const VkSemaphore*)DE_NULL,    // pSignalSemaphores
 413         };
 414         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence));
 415 }
 416
 417 void waitForFences (const DeviceInterface& vk, VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
 418 {
 419         VK_CHECK(vk.waitForFences(device, fenceCount, pFences, waitAll, timeout));
 420 }
 421
 422 VkImageAspectFlags getImageAspectFlags (VkFormat vkFormat)
 423 {
 424         const tcu::TextureFormat format = mapVkFormat(vkFormat);
 425
 426         DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
 427
 428         switch (format.order)
 429         {
 430                 case tcu::TextureFormat::DS:
 431                         return VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT;
 432
 433                 case tcu::TextureFormat::D:
 434                         return VK_IMAGE_ASPECT_DEPTH_BIT;
 435
 436                 case tcu::TextureFormat::S:
 437                         return VK_IMAGE_ASPECT_STENCIL_BIT;
 438
 439                 default:
 440                         return VK_IMAGE_ASPECT_COLOR_BIT;
 441         }
 442 }
 443
 444 VkAccessFlags getAllMemoryReadFlags (void)
 445 {
 446         return VK_ACCESS_TRANSFER_READ_BIT
 447                    | VK_ACCESS_UNIFORM_READ_BIT
 448                    | VK_ACCESS_HOST_READ_BIT
 449                    | VK_ACCESS_INDEX_READ_BIT
 450                    | VK_ACCESS_SHADER_READ_BIT
 451                    | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
 452                    | VK_ACCESS_INDIRECT_COMMAND_READ_BIT
 453                    | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
 454                    | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
 455                    | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
 456 }
 457
 458 VkAccessFlags getAllMemoryWriteFlags (void)
 459 {
 460         return VK_ACCESS_TRANSFER_WRITE_BIT
 461                    | VK_ACCESS_HOST_WRITE_BIT
 462                    | VK_ACCESS_SHADER_WRITE_BIT
 463                    | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
 464                    | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 465 }
 466
 467 VkAccessFlags getMemoryFlagsForLayout (const VkImageLayout layout)
 468 {
 469         switch (layout)
 470         {
 471                 case VK_IMAGE_LAYOUT_GENERAL:                                                                           return getAllMemoryReadFlags() | getAllMemoryWriteFlags();
 472                 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:                                          return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 473                 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:                          return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 474                 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:                           return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
 475                 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:                                          return VK_ACCESS_SHADER_READ_BIT;
 476                 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:                                                      return VK_ACCESS_TRANSFER_READ_BIT;
 477                 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:                                                      return VK_ACCESS_TRANSFER_WRITE_BIT;
 478                 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:        return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
 479                 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:        return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
 480                 default:
 481                         return (VkAccessFlags)0;
 482         }
 483 }
 484
 485 VkPipelineStageFlags getAllPipelineStageFlags (void)
 486 {
 487         return VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
 488                    | VK_PIPELINE_STAGE_TRANSFER_BIT
 489                    | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
 490                    | VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
 491                    | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
 492                    | VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
 493                    | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
 494                    | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
 495                    | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
 496                    | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
 497                    | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
 498                    | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
 499                    | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 500 }
 501
 502 class AttachmentReference
 503 {
 504 public:
 505                                         AttachmentReference             (deUint32               attachment,
 506                                                                                          VkImageLayout  layout)
 507                 : m_attachment  (attachment)
 508                 , m_layout              (layout)
 509         {
 510         }
 511
 512         deUint32                getAttachment                   (void) const { return m_attachment;     }
 513         VkImageLayout   getImageLayout                  (void) const { return m_layout;         }
 514
 515 private:
 516         deUint32                m_attachment;
 517         VkImageLayout   m_layout;
 518 };
 519
 520 class Subpass
 521 {
 522 public:
 523                                                                                 Subpass                                         (VkPipelineBindPoint                            pipelineBindPoint,
 524                                                                                                                                          VkSubpassDescriptionFlags                      flags,
 525                                                                                                                                          const vector<AttachmentReference>&     inputAttachments,
 526                                                                                                                                          const vector<AttachmentReference>&     colorAttachments,
 527                                                                                                                                          const vector<AttachmentReference>&     resolveAttachments,
 528                                                                                                                                          AttachmentReference                            depthStencilAttachment,
 529                                                                                                                                          const vector<deUint32>&                        preserveAttachments)
 530                 : m_pipelineBindPoint           (pipelineBindPoint)
 531                 , m_flags                                       (flags)
 532                 , m_inputAttachments            (inputAttachments)
 533                 , m_colorAttachments            (colorAttachments)
 534                 , m_resolveAttachments          (resolveAttachments)
 535                 , m_depthStencilAttachment      (depthStencilAttachment)
 536                 , m_preserveAttachments         (preserveAttachments)
 537         {
 538         }
 539
 540         VkPipelineBindPoint                                     getPipelineBindPoint            (void) const { return m_pipelineBindPoint;              }
 541         VkSubpassDescriptionFlags                       getFlags                                        (void) const { return m_flags;                                  }
 542         const vector<AttachmentReference>&      getInputAttachments                     (void) const { return m_inputAttachments;               }
 543         const vector<AttachmentReference>&      getColorAttachments                     (void) const { return m_colorAttachments;               }
 544         const vector<AttachmentReference>&      getResolveAttachments           (void) const { return m_resolveAttachments;             }
 545         const AttachmentReference&                      getDepthStencilAttachment       (void) const { return m_depthStencilAttachment; }
 546         const vector<deUint32>&                         getPreserveAttachments          (void) const { return m_preserveAttachments;    }
 547
 548 private:
 549         VkPipelineBindPoint                                     m_pipelineBindPoint;
 550         VkSubpassDescriptionFlags                       m_flags;
 551
 552         vector<AttachmentReference>                     m_inputAttachments;
 553         vector<AttachmentReference>                     m_colorAttachments;
 554         vector<AttachmentReference>                     m_resolveAttachments;
 555         AttachmentReference                                     m_depthStencilAttachment;
 556
 557         vector<deUint32>                                        m_preserveAttachments;
 558 };
 559
 560 class SubpassDependency
 561 {
 562 public:
 563                                                         SubpassDependency       (deUint32                               srcPass,
 564                                                                                                  deUint32                               dstPass,
 565
 566                                                                                                  VkPipelineStageFlags   srcStageMask,
 567                                                                                                  VkPipelineStageFlags   dstStageMask,
 568
 569                                                                                                  VkAccessFlags                  outputMask,
 570                                                                                                  VkAccessFlags                  inputMask,
 571
 572                                                                                                  VkDependencyFlags              flags)
 573                 : m_srcPass                     (srcPass)
 574                 , m_dstPass                     (dstPass)
 575
 576                 , m_srcStageMask        (srcStageMask)
 577                 , m_dstStageMask        (dstStageMask)
 578
 579                 , m_outputMask          (outputMask)
 580                 , m_inputMask           (inputMask)
 581                 , m_flags                       (flags)
 582         {
 583         }
 584
 585         deUint32                                getSrcPass                      (void) const { return m_srcPass;                }
 586         deUint32                                getDstPass                      (void) const { return m_dstPass;                }
 587
 588         VkPipelineStageFlags    getSrcStageMask         (void) const { return m_srcStageMask;   }
 589         VkPipelineStageFlags    getDstStageMask         (void) const { return m_dstStageMask;   }
 590
 591         VkAccessFlags                   getOutputMask           (void) const { return m_outputMask;             }
 592         VkAccessFlags                   getInputMask            (void) const { return m_inputMask;              }
 593
 594         VkDependencyFlags               getFlags                        (void) const { return m_flags;          }
 595
 596 private:
 597         deUint32                                m_srcPass;
 598         deUint32                                m_dstPass;
 599
 600         VkPipelineStageFlags    m_srcStageMask;
 601         VkPipelineStageFlags    m_dstStageMask;
 602
 603         VkAccessFlags                   m_outputMask;
 604         VkAccessFlags                   m_inputMask;
 605         VkDependencyFlags               m_flags;
 606 };
 607
 608 class Attachment
 609 {
 610 public:
 611                                                         Attachment                      (VkFormat                               format,
 612                                                                                                  VkSampleCountFlagBits  samples,
 613
 614                                                                                                  VkAttachmentLoadOp             loadOp,
 615                                                                                                  VkAttachmentStoreOp    storeOp,
 616
 617                                                                                                  VkAttachmentLoadOp             stencilLoadOp,
 618                                                                                                  VkAttachmentStoreOp    stencilStoreOp,
 619
 620                                                                                                  VkImageLayout                  initialLayout,
 621                                                                                                  VkImageLayout                  finalLayout)
 622                 : m_format                      (format)
 623                 , m_samples                     (samples)
 624
 625                 , m_loadOp                      (loadOp)
 626                 , m_storeOp                     (storeOp)
 627
 628                 , m_stencilLoadOp       (stencilLoadOp)
 629                 , m_stencilStoreOp      (stencilStoreOp)
 630
 631                 , m_initialLayout       (initialLayout)
 632                 , m_finalLayout         (finalLayout)
 633         {
 634         }
 635
 636         VkFormat                                getFormat                       (void) const { return m_format;                 }
 637         VkSampleCountFlagBits   getSamples                      (void) const { return m_samples;                }
 638
 639         VkAttachmentLoadOp              getLoadOp                       (void) const { return m_loadOp;                 }
 640         VkAttachmentStoreOp             getStoreOp                      (void) const { return m_storeOp;                }
 641
 642
 643         VkAttachmentLoadOp              getStencilLoadOp        (void) const { return m_stencilLoadOp;  }
 644         VkAttachmentStoreOp             getStencilStoreOp       (void) const { return m_stencilStoreOp; }
 645
 646         VkImageLayout                   getInitialLayout        (void) const { return m_initialLayout;  }
 647         VkImageLayout                   getFinalLayout          (void) const { return m_finalLayout;    }
 648
 649 private:
 650         VkFormat                                m_format;
 651         VkSampleCountFlagBits   m_samples;
 652
 653         VkAttachmentLoadOp              m_loadOp;
 654         VkAttachmentStoreOp             m_storeOp;
 655
 656         VkAttachmentLoadOp              m_stencilLoadOp;
 657         VkAttachmentStoreOp             m_stencilStoreOp;
 658
 659         VkImageLayout                   m_initialLayout;
 660         VkImageLayout                   m_finalLayout;
 661 };
 662
 663 class RenderPass
 664 {
 665 public:
 666                                                                                                                 RenderPass              (const vector<Attachment>&                                                      attachments,
 667                                                                                                                                                  const vector<Subpass>&                                                         subpasses,
 668                                                                                                                                                  const vector<SubpassDependency>&                                       dependencies,
 669                                                                                                                                                  const vector<VkInputAttachmentAspectReference> inputAspects = vector<VkInputAttachmentAspectReference>())
 670                 : m_attachments         (attachments)
 671                 , m_subpasses           (subpasses)
 672                 , m_dependencies        (dependencies)
 673                 , m_inputAspects        (inputAspects)
 674         {
 675         }
 676
 677         const vector<Attachment>&                                                       getAttachments  (void) const { return m_attachments;    }
 678         const vector<Subpass>&                                                          getSubpasses    (void) const { return m_subpasses;              }
 679         const vector<SubpassDependency>&                                        getDependencies (void) const { return m_dependencies;   }
 680         const vector<VkInputAttachmentAspectReference>&         getInputAspects (void) const { return m_inputAspects;   }
 681
 682 private:
 683         const vector<Attachment>                                                        m_attachments;
 684         const vector<Subpass>                                                           m_subpasses;
 685         const vector<SubpassDependency>                                         m_dependencies;
 686         const vector<VkInputAttachmentAspectReference>          m_inputAspects;
 687 };
 688
 689 struct TestConfig
 690 {
 691         enum RenderTypes
 692         {
 693                 RENDERTYPES_NONE        = 0,
 694                 RENDERTYPES_CLEAR       = (1<<1),
 695                 RENDERTYPES_DRAW        = (1<<2)
 696         };
 697
 698         enum CommandBufferTypes
 699         {
 700                 COMMANDBUFFERTYPES_INLINE               = (1<<0),
 701                 COMMANDBUFFERTYPES_SECONDARY    = (1<<1)
 702         };
 703
 704         enum ImageMemory
 705         {
 706                 IMAGEMEMORY_STRICT              = (1<<0),
 707                 IMAGEMEMORY_LAZY                = (1<<1)
 708         };
 709
 710                                                 TestConfig (const RenderPass&   renderPass_,
 711                                                                         RenderTypes                     renderTypes_,
 712                                                                         CommandBufferTypes      commandBufferTypes_,
 713                                                                         ImageMemory                     imageMemory_,
 714                                                                         const UVec2&            targetSize_,
 715                                                                         const UVec2&            renderPos_,
 716                                                                         const UVec2&            renderSize_,
 717                                                                         deUint32                        seed_,
 718                                                                         AllocationKind          allocationKind_)
 719                 : renderPass                    (renderPass_)
 720                 , renderTypes                   (renderTypes_)
 721                 , commandBufferTypes    (commandBufferTypes_)
 722                 , imageMemory                   (imageMemory_)
 723                 , targetSize                    (targetSize_)
 724                 , renderPos                             (renderPos_)
 725                 , renderSize                    (renderSize_)
 726                 , seed                                  (seed_)
 727                 , allocationKind                (allocationKind_)
 728         {
 729         }
 730
 731         RenderPass                      renderPass;
 732         RenderTypes                     renderTypes;
 733         CommandBufferTypes      commandBufferTypes;
 734         ImageMemory                     imageMemory;
 735         UVec2                           targetSize;
 736         UVec2                           renderPos;
 737         UVec2                           renderSize;
 738         deUint32                        seed;
 739         AllocationKind          allocationKind;
 740 };
 741
 742 TestConfig::RenderTypes operator| (TestConfig::RenderTypes a, TestConfig::RenderTypes b)
 743 {
 744         return (TestConfig::RenderTypes)(((deUint32)a) | ((deUint32)b));
 745 }
 746
 747 TestConfig::CommandBufferTypes operator| (TestConfig::CommandBufferTypes a, TestConfig::CommandBufferTypes b)
 748 {
 749         return (TestConfig::CommandBufferTypes)(((deUint32)a) | ((deUint32)b));
 750 }
 751
 752 TestConfig::ImageMemory operator| (TestConfig::ImageMemory a, TestConfig::ImageMemory b)
 753 {
 754         return (TestConfig::ImageMemory)(((deUint32)a) | ((deUint32)b));
 755 }
 756
 757 void logRenderPassInfo (TestLog&                        log,
 758                                                 const RenderPass&       renderPass)
 759 {
 760         const tcu::ScopedLogSection section (log, "RenderPass", "RenderPass");
 761
 762         {
 763                 const tcu::ScopedLogSection     attachmentsSection      (log, "Attachments", "Attachments");
 764                 const vector<Attachment>&       attachments                     = renderPass.getAttachments();
 765
 766                 for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
 767                 {
 768                         const tcu::ScopedLogSection     attachmentSection       (log, "Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx));
 769                         const Attachment&                       attachment                      = attachments[attachmentNdx];
 770
 771                         log << TestLog::Message << "Format: " << attachment.getFormat() << TestLog::EndMessage;
 772                         log << TestLog::Message << "Samples: " << attachment.getSamples() << TestLog::EndMessage;
 773
 774                         log << TestLog::Message << "LoadOp: " << attachment.getLoadOp() << TestLog::EndMessage;
 775                         log << TestLog::Message << "StoreOp: " << attachment.getStoreOp() << TestLog::EndMessage;
 776
 777                         log << TestLog::Message << "StencilLoadOp: " << attachment.getStencilLoadOp() << TestLog::EndMessage;
 778                         log << TestLog::Message << "StencilStoreOp: " << attachment.getStencilStoreOp() << TestLog::EndMessage;
 779
 780                         log << TestLog::Message << "InitialLayout: " << attachment.getInitialLayout() << TestLog::EndMessage;
 781                         log << TestLog::Message << "FinalLayout: " << attachment.getFinalLayout() << TestLog::EndMessage;
 782                 }
 783         }
 784
 785         if (!renderPass.getInputAspects().empty())
 786         {
 787                 const tcu::ScopedLogSection     inputAspectSection      (log, "InputAspects", "InputAspects");
 788
 789                 for (size_t aspectNdx = 0; aspectNdx < renderPass.getInputAspects().size(); aspectNdx++)
 790                 {
 791                         const VkInputAttachmentAspectReference& inputAspect     (renderPass.getInputAspects()[aspectNdx]);
 792
 793                         log << TestLog::Message << "Subpass: " << inputAspect.subpass << TestLog::EndMessage;
 794                         log << TestLog::Message << "InputAttachmentIndex: " << inputAspect.inputAttachmentIndex << TestLog::EndMessage;
 795                         log << TestLog::Message << "AspectFlags: " << getImageAspectFlagsStr(inputAspect.aspectMask) << TestLog::EndMessage;
 796                 }
 797         }
 798
 799         {
 800                 const tcu::ScopedLogSection     subpassesSection        (log, "Subpasses", "Subpasses");
 801                 const vector<Subpass>&          subpasses                       = renderPass.getSubpasses();
 802
 803                 for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
 804                 {
 805                         const tcu::ScopedLogSection                     subpassSection          (log, "Subpass" + de::toString(subpassNdx), "Subpass " + de::toString(subpassNdx));
 806                         const Subpass&                                          subpass                         = subpasses[subpassNdx];
 807
 808                         const vector<AttachmentReference>&      inputAttachments        = subpass.getInputAttachments();
 809                         const vector<AttachmentReference>&      colorAttachments        = subpass.getColorAttachments();
 810                         const vector<AttachmentReference>&      resolveAttachments      = subpass.getResolveAttachments();
 811                         const vector<deUint32>&                         preserveAttachments     = subpass.getPreserveAttachments();
 812
 813                         if (!inputAttachments.empty())
 814                         {
 815                                 const tcu::ScopedLogSection     inputAttachmentsSection (log, "Inputs", "Inputs");
 816
 817                                 for (size_t inputNdx = 0; inputNdx < inputAttachments.size(); inputNdx++)
 818                                 {
 819                                         const tcu::ScopedLogSection     inputAttachmentSection  (log, "Input" + de::toString(inputNdx), "Input " + de::toString(inputNdx));
 820                                         const AttachmentReference&      inputAttachment                 = inputAttachments[inputNdx];
 821
 822                                         log << TestLog::Message << "Attachment: " << inputAttachment.getAttachment() << TestLog::EndMessage;
 823                                         log << TestLog::Message << "Layout: " << inputAttachment.getImageLayout() << TestLog::EndMessage;
 824                                 }
 825                         }
 826
 827                         if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
 828                         {
 829                                 const tcu::ScopedLogSection     depthStencilAttachmentSection   (log, "DepthStencil", "DepthStencil");
 830                                 const AttachmentReference&      depthStencilAttachment                  = subpass.getDepthStencilAttachment();
 831
 832                                 log << TestLog::Message << "Attachment: " << depthStencilAttachment.getAttachment() << TestLog::EndMessage;
 833                                 log << TestLog::Message << "Layout: " << depthStencilAttachment.getImageLayout() << TestLog::EndMessage;
 834                         }
 835
 836                         if (!colorAttachments.empty())
 837                         {
 838                                 const tcu::ScopedLogSection     colorAttachmentsSection (log, "Colors", "Colors");
 839
 840                                 for (size_t colorNdx = 0; colorNdx < colorAttachments.size(); colorNdx++)
 841                                 {
 842                                         const tcu::ScopedLogSection     colorAttachmentSection  (log, "Color" + de::toString(colorNdx), "Color " + de::toString(colorNdx));
 843                                         const AttachmentReference&      colorAttachment                 = colorAttachments[colorNdx];
 844
 845                                         log << TestLog::Message << "Attachment: " << colorAttachment.getAttachment() << TestLog::EndMessage;
 846                                         log << TestLog::Message << "Layout: " << colorAttachment.getImageLayout() << TestLog::EndMessage;
 847                                 }
 848                         }
 849
 850                         if (!resolveAttachments.empty())
 851                         {
 852                                 const tcu::ScopedLogSection     resolveAttachmentsSection       (log, "Resolves", "Resolves");
 853
 854                                 for (size_t resolveNdx = 0; resolveNdx < resolveAttachments.size(); resolveNdx++)
 855                                 {
 856                                         const tcu::ScopedLogSection     resolveAttachmentSection        (log, "Resolve" + de::toString(resolveNdx), "Resolve " + de::toString(resolveNdx));
 857                                         const AttachmentReference&      resolveAttachment                       = resolveAttachments[resolveNdx];
 858
 859                                         log << TestLog::Message << "Attachment: " << resolveAttachment.getAttachment() << TestLog::EndMessage;
 860                                         log << TestLog::Message << "Layout: " << resolveAttachment.getImageLayout() << TestLog::EndMessage;
 861                                 }
 862                         }
 863
 864                         if (!preserveAttachments.empty())
 865                         {
 866                                 const tcu::ScopedLogSection     preserveAttachmentsSection      (log, "Preserves", "Preserves");
 867
 868                                 for (size_t preserveNdx = 0; preserveNdx < preserveAttachments.size(); preserveNdx++)
 869                                 {
 870                                         const tcu::ScopedLogSection     preserveAttachmentSection       (log, "Preserve" + de::toString(preserveNdx), "Preserve " + de::toString(preserveNdx));
 871                                         const deUint32                          preserveAttachment                      = preserveAttachments[preserveNdx];
 872
 873                                         log << TestLog::Message << "Attachment: " << preserveAttachment << TestLog::EndMessage;
 874                                 }
 875                         }
 876                 }
 877
 878         }
 879
 880         if (!renderPass.getDependencies().empty())
 881         {
 882                 const tcu::ScopedLogSection     dependenciesSection     (log, "Dependencies", "Dependencies");
 883
 884                 for (size_t depNdx = 0; depNdx < renderPass.getDependencies().size(); depNdx++)
 885                 {
 886                         const tcu::ScopedLogSection     dependencySection       (log, "Dependency" + de::toString(depNdx), "Dependency " + de::toString(depNdx));
 887                         const SubpassDependency&        dep                                     = renderPass.getDependencies()[depNdx];
 888
 889                         log << TestLog::Message << "Source: " << dep.getSrcPass() << TestLog::EndMessage;
 890                         log << TestLog::Message << "Destination: " << dep.getDstPass() << TestLog::EndMessage;
 891
 892                         log << TestLog::Message << "Source Stage Mask: " << dep.getSrcStageMask() << TestLog::EndMessage;
 893                         log << TestLog::Message << "Destination Stage Mask: " << dep.getDstStageMask() << TestLog::EndMessage;
 894
 895                         log << TestLog::Message << "Input Mask: " << dep.getInputMask() << TestLog::EndMessage;
 896                         log << TestLog::Message << "Output Mask: " << dep.getOutputMask() << TestLog::EndMessage;
 897                         log << TestLog::Message << "Dependency Flags: " << getDependencyFlagsStr(dep.getFlags()) << TestLog::EndMessage;
 898                 }
 899         }
 900 }
 901
 902 std::string clearColorToString (VkFormat vkFormat, VkClearColorValue value)
 903 {
 904         const tcu::TextureFormat                format                  = mapVkFormat(vkFormat);
 905         const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(format.type);
 906         const tcu::BVec4                                channelMask             = tcu::getTextureFormatChannelMask(format);
 907
 908         std::ostringstream                              stream;
 909
 910         stream << "(";
 911
 912         switch (channelClass)
 913         {
 914                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 915                         for (int i = 0; i < 4; i++)
 916                         {
 917                                 if (i > 0)
 918                                         stream << ", ";
 919
 920                                 if (channelMask[i])
 921                                         stream << value.int32[i];
 922                                 else
 923                                         stream << "Undef";
 924                         }
 925                         break;
 926
 927                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 928                         for (int i = 0; i < 4; i++)
 929                         {
 930                                 if (i > 0)
 931                                         stream << ", ";
 932
 933                                 if (channelMask[i])
 934                                         stream << value.uint32[i];
 935                                 else
 936                                         stream << "Undef";
 937                         }
 938                         break;
 939
 940                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 941                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 942                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 943                         for (int i = 0; i < 4; i++)
 944                         {
 945                                 if (i > 0)
 946                                         stream << ", ";
 947
 948                                 if (channelMask[i])
 949                                         stream << value.float32[i];
 950                                 else
 951                                         stream << "Undef";
 952                         }
 953                         break;
 954
 955                 default:
 956                         DE_FATAL("Unknown channel class");
 957         }
 958
 959         stream << ")";
 960
 961         return stream.str();
 962 }
 963
 964 std::string clearValueToString (VkFormat vkFormat, VkClearValue value)
 965 {
 966         const tcu::TextureFormat        format  = mapVkFormat(vkFormat);
 967
 968         if (tcu::hasStencilComponent(format.order) || tcu::hasDepthComponent(format.order))
 969         {
 970                 std::ostringstream stream;
 971
 972                 stream << "(";
 973
 974                 if (tcu::hasStencilComponent(format.order))
 975                         stream << "stencil: " << value.depthStencil.stencil;
 976
 977                 if (tcu::hasStencilComponent(format.order) && tcu::hasDepthComponent(format.order))
 978                         stream << ", ";
 979
 980                 if (tcu::hasDepthComponent(format.order))
 981                         stream << "depth: " << value.depthStencil.depth;
 982
 983                 stream << ")";
 984
 985                 return stream.str();
 986         }
 987         else
 988                 return clearColorToString(vkFormat, value.color);
 989 }
 990
 991 VkClearColorValue randomColorClearValue (const Attachment& attachment, de::Random& rng)
 992 {
 993         const float                                             clearNan                = tcu::Float32::nan().asFloat();
 994         const tcu::TextureFormat                format                  = mapVkFormat(attachment.getFormat());
 995         const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(format.type);
 996         const tcu::BVec4                                channelMask             = tcu::getTextureFormatChannelMask(format);
 997         VkClearColorValue                               clearColor;
 998
 999         switch (channelClass)
1000         {
1001                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1002                 {
1003                         for (int ndx = 0; ndx < 4; ndx++)
1004                         {
1005                                 if (!channelMask[ndx])
1006                                         clearColor.int32[ndx] = std::numeric_limits<deInt32>::min();
1007                                 else
1008                                         clearColor.uint32[ndx] = rng.getBool() ? 1u : 0u;
1009                         }
1010                         break;
1011                 }
1012
1013                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1014                 {
1015                         for (int ndx = 0; ndx < 4; ndx++)
1016                         {
1017                                 if (!channelMask[ndx])
1018                                         clearColor.uint32[ndx] = std::numeric_limits<deUint32>::max();
1019                                 else
1020                                         clearColor.uint32[ndx] = rng.getBool() ? 1u : 0u;
1021                         }
1022                         break;
1023                 }
1024
1025                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1026                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1027                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1028                 {
1029                         for (int ndx = 0; ndx < 4; ndx++)
1030                         {
1031                                 if (!channelMask[ndx])
1032                                         clearColor.float32[ndx] = clearNan;
1033                                 else
1034                                         clearColor.float32[ndx] = rng.getBool() ? 1.0f : 0.0f;
1035                         }
1036                         break;
1037                 }
1038
1039                 default:
1040                         DE_FATAL("Unknown channel class");
1041         }
1042
1043         return clearColor;
1044 }
1045
1046 VkAttachmentDescription createAttachmentDescription (const Attachment& attachment)
1047 {
1048         const VkAttachmentDescription attachmentDescription =
1049         {
1050                 0,                                                              // flags
1051
1052                 attachment.getFormat(),                 // format
1053                 attachment.getSamples(),                // samples
1054
1055                 attachment.getLoadOp(),                 // loadOp
1056                 attachment.getStoreOp(),                // storeOp
1057
1058                 attachment.getStencilLoadOp(),  // stencilLoadOp
1059                 attachment.getStencilStoreOp(), // stencilStoreOp
1060
1061                 attachment.getInitialLayout(),  // initialLayout
1062                 attachment.getFinalLayout(),    // finalLayout
1063         };
1064
1065         return attachmentDescription;
1066 }
1067
1068 VkAttachmentReference createAttachmentReference (const AttachmentReference& referenceInfo)
1069 {
1070         const VkAttachmentReference reference =
1071         {
1072                 referenceInfo.getAttachment(),  // attachment;
1073                 referenceInfo.getImageLayout()  // layout;
1074         };
1075
1076         return reference;
1077 }
1078
1079 VkSubpassDescription createSubpassDescription (const Subpass&                                   subpass,
1080                                                                                            vector<VkAttachmentReference>*       attachmentReferenceLists,
1081                                                                                            vector<deUint32>*                            preserveAttachmentReferences)
1082 {
1083         vector<VkAttachmentReference>&  inputAttachmentReferences                       = attachmentReferenceLists[0];
1084         vector<VkAttachmentReference>&  colorAttachmentReferences                       = attachmentReferenceLists[1];
1085         vector<VkAttachmentReference>&  resolveAttachmentReferences                     = attachmentReferenceLists[2];
1086         vector<VkAttachmentReference>&  depthStencilAttachmentReferences        = attachmentReferenceLists[3];
1087
1088         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
1089                 colorAttachmentReferences.push_back(createAttachmentReference(subpass.getColorAttachments()[attachmentNdx]));
1090
1091         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
1092                 inputAttachmentReferences.push_back(createAttachmentReference(subpass.getInputAttachments()[attachmentNdx]));
1093
1094         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++)
1095                 resolveAttachmentReferences.push_back(createAttachmentReference(subpass.getResolveAttachments()[attachmentNdx]));
1096
1097         depthStencilAttachmentReferences.push_back(createAttachmentReference(subpass.getDepthStencilAttachment()));
1098
1099         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getPreserveAttachments().size(); attachmentNdx++)
1100                 preserveAttachmentReferences->push_back(subpass.getPreserveAttachments()[attachmentNdx]);
1101
1102         DE_ASSERT(resolveAttachmentReferences.empty() || colorAttachmentReferences.size() == resolveAttachmentReferences.size());
1103
1104         {
1105                 const VkSubpassDescription subpassDescription =
1106                 {
1107                         subpass.getFlags(),                                                                                                                                             // flags;
1108                         subpass.getPipelineBindPoint(),                                                                                                                 // pipelineBindPoint;
1109
1110                         (deUint32)inputAttachmentReferences.size(),                                                                                             // inputCount;
1111                         inputAttachmentReferences.empty() ? DE_NULL : &inputAttachmentReferences[0],                    // inputAttachments;
1112
1113                         (deUint32)colorAttachmentReferences.size(),                                                                                             // colorCount;
1114                         colorAttachmentReferences.empty() ? DE_NULL :  &colorAttachmentReferences[0],                   // colorAttachments;
1115                         resolveAttachmentReferences.empty() ? DE_NULL : &resolveAttachmentReferences[0],                // resolveAttachments;
1116
1117                         &depthStencilAttachmentReferences[0],                                                                                                   // pDepthStencilAttachment;
1118                         (deUint32)preserveAttachmentReferences->size(),                                                                                 // preserveCount;
1119                         preserveAttachmentReferences->empty() ? DE_NULL : &(*preserveAttachmentReferences)[0]   // preserveAttachments;
1120                 };
1121
1122                 return subpassDescription;
1123         }
1124 }
1125
1126 VkSubpassDependency createSubpassDependency     (const SubpassDependency& dependencyInfo)
1127 {
1128         const VkSubpassDependency dependency =
1129         {
1130                 dependencyInfo.getSrcPass(),            // srcSubpass;
1131                 dependencyInfo.getDstPass(),            // destSubpass;
1132
1133                 dependencyInfo.getSrcStageMask(),       // srcStageMask;
1134                 dependencyInfo.getDstStageMask(),       // destStageMask;
1135
1136                 dependencyInfo.getOutputMask(),         // outputMask;
1137                 dependencyInfo.getInputMask(),          // inputMask;
1138
1139                 dependencyInfo.getFlags()                       // dependencyFlags;
1140         };
1141
1142         return dependency;
1143 }
1144
1145 Move<VkRenderPass> createRenderPass (const DeviceInterface&     vk,
1146                                                                          VkDevice                               device,
1147                                                                          const RenderPass&              renderPassInfo)
1148 {
1149         const size_t                                                            perSubpassAttachmentReferenceLists = 4;
1150         vector<VkAttachmentDescription>                         attachments;
1151         vector<VkSubpassDescription>                            subpasses;
1152         vector<VkSubpassDependency>                                     dependencies;
1153         vector<vector<VkAttachmentReference> >          attachmentReferenceLists(renderPassInfo.getSubpasses().size() * perSubpassAttachmentReferenceLists);
1154         vector<vector<deUint32> >                                       preserveAttachments(renderPassInfo.getSubpasses().size());
1155
1156         for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
1157                 attachments.push_back(createAttachmentDescription(renderPassInfo.getAttachments()[attachmentNdx]));
1158
1159         for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
1160                 subpasses.push_back(createSubpassDescription(renderPassInfo.getSubpasses()[subpassNdx], &(attachmentReferenceLists[subpassNdx * perSubpassAttachmentReferenceLists]), &preserveAttachments[subpassNdx]));
1161
1162         for (size_t depNdx = 0; depNdx < renderPassInfo.getDependencies().size(); depNdx++)
1163                 dependencies.push_back(createSubpassDependency(renderPassInfo.getDependencies()[depNdx]));
1164
1165         if (renderPassInfo.getInputAspects().empty())
1166         {
1167                 const VkRenderPassCreateInfo    createInfo      =
1168                 {
1169                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1170                         DE_NULL,
1171                         (VkRenderPassCreateFlags)0u,
1172                         (deUint32)attachments.size(),
1173                         (attachments.empty() ? DE_NULL : &attachments[0]),
1174                         (deUint32)subpasses.size(),
1175                         (subpasses.empty() ? DE_NULL : &subpasses[0]),
1176                         (deUint32)dependencies.size(),
1177                         (dependencies.empty() ? DE_NULL : &dependencies[0])
1178                 };
1179
1180                 return createRenderPass(vk, device, &createInfo);
1181         }
1182         else
1183         {
1184                 const VkRenderPassInputAttachmentAspectCreateInfo       inputAspectCreateInfo   =
1185                 {
1186                         VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
1187                         DE_NULL,
1188
1189                         (deUint32)renderPassInfo.getInputAspects().size(),
1190                         renderPassInfo.getInputAspects().data(),
1191                 };
1192                 const VkRenderPassCreateInfo                                                    createInfo                              =
1193                 {
1194                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1195                         &inputAspectCreateInfo,
1196                         (VkRenderPassCreateFlags)0u,
1197                         (deUint32)attachments.size(),
1198                         (attachments.empty() ? DE_NULL : &attachments[0]),
1199                         (deUint32)subpasses.size(),
1200                         (subpasses.empty() ? DE_NULL : &subpasses[0]),
1201                         (deUint32)dependencies.size(),
1202                         (dependencies.empty() ? DE_NULL : &dependencies[0])
1203                 };
1204
1205                 return createRenderPass(vk, device, &createInfo);
1206         }
1207 }
1208
1209 Move<VkFramebuffer> createFramebuffer (const DeviceInterface&           vk,
1210                                                                            VkDevice                                             device,
1211                                                                            VkRenderPass                                 renderPass,
1212                                                                            const UVec2&                                 size,
1213                                                                            const vector<VkImageView>&   attachments)
1214 {
1215         return createFramebuffer(vk, device, 0u, renderPass, (deUint32)attachments.size(), attachments.empty() ? DE_NULL : &attachments[0], size.x(), size.y(), 1u);
1216 }
1217
1218 Move<VkImage> createAttachmentImage (const DeviceInterface&     vk,
1219                                                                          VkDevice                               device,
1220                                                                          deUint32                               queueIndex,
1221                                                                          const UVec2&                   size,
1222                                                                          VkFormat                               format,
1223                                                                          VkSampleCountFlagBits  samples,
1224                                                                          VkImageUsageFlags              usageFlags,
1225                                                                          VkImageLayout                  layout)
1226 {
1227         VkImageUsageFlags                       targetUsageFlags        = 0;
1228         const tcu::TextureFormat        textureFormat           = mapVkFormat(format);
1229
1230         DE_ASSERT(!(tcu::hasDepthComponent(vk::mapVkFormat(format).order) || tcu::hasStencilComponent(vk::mapVkFormat(format).order))
1231                                         || ((usageFlags & vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) == 0));
1232
1233         DE_ASSERT((tcu::hasDepthComponent(vk::mapVkFormat(format).order) || tcu::hasStencilComponent(vk::mapVkFormat(format).order))
1234                                         || ((usageFlags & vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0));
1235
1236         if (tcu::hasDepthComponent(textureFormat.order) || tcu::hasStencilComponent(textureFormat.order))
1237                 targetUsageFlags |= vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
1238         else
1239                 targetUsageFlags |= vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
1240
1241         return createImage(vk, device,
1242                                            (VkImageCreateFlags)0,
1243                                            VK_IMAGE_TYPE_2D,
1244                                            format,
1245                                            vk::makeExtent3D(size.x(), size.y(), 1u),
1246                                            1u /* mipLevels */,
1247                                            1u /* arraySize */,
1248                                            samples,
1249                                            VK_IMAGE_TILING_OPTIMAL,
1250                                            usageFlags | targetUsageFlags,
1251                                            VK_SHARING_MODE_EXCLUSIVE,
1252                                            1,
1253                                            &queueIndex,
1254                                            layout);
1255 }
1256
1257 de::MovePtr<Allocation> createImageMemory (const InstanceInterface&     vki,
1258                                                                                    const VkPhysicalDevice&      vkd,
1259                                                                                    const DeviceInterface&       vk,
1260                                                                                    VkDevice                                     device,
1261                                                                                    Allocator&                           allocator,
1262                                                                                    VkImage                                      image,
1263                                                                                    bool                                         lazy,
1264                                                                                    AllocationKind                       allocationKind)
1265 {
1266         const MemoryRequirement memoryRequirement       = lazy ? MemoryRequirement::LazilyAllocated : MemoryRequirement::Any;
1267         de::MovePtr<Allocation> allocation                      = allocateImage(vki, vk, vkd, device, image, memoryRequirement, allocator, allocationKind);
1268
1269         bindImageMemory(vk, device, image, allocation->getMemory(), allocation->getOffset());
1270
1271         return allocation;
1272 }
1273
1274 Move<VkImageView> createImageAttachmentView (const DeviceInterface&     vk,
1275                                                                                          VkDevice                               device,
1276                                                                                          VkImage                                image,
1277                                                                                          VkFormat                               format,
1278                                                                                          VkImageAspectFlags             aspect)
1279 {
1280         const VkImageSubresourceRange range =
1281         {
1282                 aspect,
1283                 0,
1284                 1,
1285                 0,
1286                 1
1287         };
1288
1289         return createImageView(vk, device, 0u, image, VK_IMAGE_VIEW_TYPE_2D, format, makeComponentMappingRGBA(), range);
1290 }
1291
1292 VkClearValue randomClearValue (const Attachment& attachment, de::Random& rng)
1293 {
1294         const float                                     clearNan        = tcu::Float32::nan().asFloat();
1295         const tcu::TextureFormat        format          = mapVkFormat(attachment.getFormat());
1296
1297         if (tcu::hasStencilComponent(format.order) || tcu::hasDepthComponent(format.order))
1298         {
1299                 VkClearValue clearValue;
1300
1301                 clearValue.depthStencil.depth   = clearNan;
1302                 clearValue.depthStencil.stencil = 0xCDu;
1303
1304                 if (tcu::hasStencilComponent(format.order))
1305                         clearValue.depthStencil.stencil = rng.getBool()
1306                                                                                         ? 0xFFu
1307                                                                                         : 0x0u;
1308
1309                 if (tcu::hasDepthComponent(format.order))
1310                         clearValue.depthStencil.depth   = rng.getBool()
1311                                                                                         ? 1.0f
1312                                                                                         : 0.0f;
1313
1314                 return clearValue;
1315         }
1316         else
1317         {
1318                 VkClearValue clearValue;
1319
1320                 clearValue.color = randomColorClearValue(attachment, rng);
1321
1322                 return clearValue;
1323         }
1324 }
1325
1326 class AttachmentResources
1327 {
1328 public:
1329         AttachmentResources (const InstanceInterface&   vki,
1330                                                  const VkPhysicalDevice&        physDevice,
1331                                                  const DeviceInterface&         vk,
1332                                                  VkDevice                                       device,
1333                                                  Allocator&                                     allocator,
1334                                                  deUint32                                       queueIndex,
1335                                                  const UVec2&                           size,
1336                                                  const Attachment&                      attachmentInfo,
1337                                                  VkImageUsageFlags                      usageFlags,
1338                                                  const AllocationKind           allocationKind)
1339                 : m_image                       (createAttachmentImage(vk, device, queueIndex, size, attachmentInfo.getFormat(), attachmentInfo.getSamples(), usageFlags, VK_IMAGE_LAYOUT_UNDEFINED))
1340                 , m_imageMemory         (createImageMemory(vki, physDevice, vk, device, allocator, *m_image, ((usageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0), allocationKind))
1341                 , m_attachmentView      (createImageAttachmentView(vk, device, *m_image, attachmentInfo.getFormat(), getImageAspectFlags(attachmentInfo.getFormat())))
1342         {
1343                 const tcu::TextureFormat        format                  = mapVkFormat(attachmentInfo.getFormat());
1344                 const bool                                      isDepthFormat   = tcu::hasDepthComponent(format.order);
1345                 const bool                                      isStencilFormat = tcu::hasStencilComponent(format.order);
1346
1347                 if (isDepthFormat && isStencilFormat)
1348                 {
1349                         m_depthInputAttachmentView              = createImageAttachmentView(vk, device, *m_image, attachmentInfo.getFormat(), VK_IMAGE_ASPECT_DEPTH_BIT);
1350                         m_stencilInputAttachmentView    = createImageAttachmentView(vk, device, *m_image, attachmentInfo.getFormat(), VK_IMAGE_ASPECT_STENCIL_BIT);
1351
1352                         m_inputAttachmentViews = std::make_pair(*m_depthInputAttachmentView, *m_stencilInputAttachmentView);
1353                 }
1354                 else
1355                         m_inputAttachmentViews = std::make_pair(*m_attachmentView, (vk::VkImageView)0u);
1356
1357                 if ((usageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) == 0)
1358                 {
1359                         if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
1360                         {
1361                                 const tcu::TextureFormat        depthFormat             = getDepthCopyFormat(attachmentInfo.getFormat());
1362                                 const tcu::TextureFormat        stencilFormat   = getStencilCopyFormat(attachmentInfo.getFormat());
1363
1364                                 m_bufferSize                    = size.x() * size.y() * depthFormat.getPixelSize();
1365                                 m_secondaryBufferSize   = size.x() * size.y() * stencilFormat.getPixelSize();
1366
1367                                 m_buffer                                = createBuffer(vk, device, 0, m_bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
1368                                 m_bufferMemory                  = allocateBuffer(vki, vk, physDevice, device, *m_buffer, MemoryRequirement::HostVisible, allocator, allocationKind);
1369
1370                                 bindBufferMemory(vk, device, *m_buffer, m_bufferMemory->getMemory(), m_bufferMemory->getOffset());
1371
1372                                 m_secondaryBuffer               = createBuffer(vk, device, 0, m_secondaryBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
1373                                 m_secondaryBufferMemory = allocateBuffer(vki, vk, physDevice, device, *m_secondaryBuffer, MemoryRequirement::HostVisible, allocator, allocationKind);
1374
1375                                 bindBufferMemory(vk, device, *m_secondaryBuffer, m_secondaryBufferMemory->getMemory(), m_secondaryBufferMemory->getOffset());
1376                         }
1377                         else
1378                         {
1379                                 m_bufferSize    = size.x() * size.y() * format.getPixelSize();
1380
1381                                 m_buffer                = createBuffer(vk, device, 0, m_bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_SHARING_MODE_EXCLUSIVE, 1, &queueIndex);
1382                                 m_bufferMemory  = allocateBuffer(vki, vk, physDevice, device, *m_buffer, MemoryRequirement::HostVisible, allocator, allocationKind);
1383
1384                                 bindBufferMemory(vk, device, *m_buffer, m_bufferMemory->getMemory(), m_bufferMemory->getOffset());
1385                         }
1386                 }
1387         }
1388
1389         const pair<VkImageView, VkImageView>& getInputAttachmentViews (void) const
1390         {
1391                 return m_inputAttachmentViews;
1392         }
1393
1394         ~AttachmentResources (void)
1395         {
1396         }
1397
1398         VkImageView getAttachmentView (void) const
1399         {
1400                 return *m_attachmentView;
1401         }
1402
1403         VkImage getImage (void) const
1404         {
1405                 return *m_image;
1406         }
1407
1408         VkBuffer getBuffer (void) const
1409         {
1410                 DE_ASSERT(*m_buffer != DE_NULL);
1411                 return *m_buffer;
1412         }
1413
1414         VkDeviceSize getBufferSize (void) const
1415         {
1416                 DE_ASSERT(*m_buffer != DE_NULL);
1417                 return m_bufferSize;
1418         }
1419
1420         const Allocation& getResultMemory (void) const
1421         {
1422                 DE_ASSERT(m_bufferMemory);
1423                 return *m_bufferMemory;
1424         }
1425
1426         VkBuffer getSecondaryBuffer (void) const
1427         {
1428                 DE_ASSERT(*m_secondaryBuffer != DE_NULL);
1429                 return *m_secondaryBuffer;
1430         }
1431
1432         VkDeviceSize getSecondaryBufferSize (void) const
1433         {
1434                 DE_ASSERT(*m_secondaryBuffer != DE_NULL);
1435                 return m_secondaryBufferSize;
1436         }
1437
1438         const Allocation& getSecondaryResultMemory (void) const
1439         {
1440                 DE_ASSERT(m_secondaryBufferMemory);
1441                 return *m_secondaryBufferMemory;
1442         }
1443
1444 private:
1445         const Unique<VkImage>                   m_image;
1446         const UniquePtr<Allocation>             m_imageMemory;
1447         const Unique<VkImageView>               m_attachmentView;
1448
1449         Move<VkImageView>                               m_depthInputAttachmentView;
1450         Move<VkImageView>                               m_stencilInputAttachmentView;
1451         pair<VkImageView, VkImageView>  m_inputAttachmentViews;
1452
1453         Move<VkBuffer>                                  m_buffer;
1454         VkDeviceSize                                    m_bufferSize;
1455         de::MovePtr<Allocation>                 m_bufferMemory;
1456
1457         Move<VkBuffer>                                  m_secondaryBuffer;
1458         VkDeviceSize                                    m_secondaryBufferSize;
1459         de::MovePtr<Allocation>                 m_secondaryBufferMemory;
1460 };
1461
1462 void uploadBufferData (const DeviceInterface&   vk,
1463                                            VkDevice                                     device,
1464                                            const Allocation&            memory,
1465                                            size_t                                       size,
1466                                            const void*                          data)
1467 {
1468         const VkMappedMemoryRange range =
1469         {
1470                 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,  // sType;
1471                 DE_NULL,                                                                // pNext;
1472                 memory.getMemory(),                                             // mem;
1473                 memory.getOffset(),                                             // offset;
1474                 (VkDeviceSize)size                                              // size;
1475         };
1476         void* const ptr = memory.getHostPtr();
1477
1478         deMemcpy(ptr, data, size);
1479         VK_CHECK(vk.flushMappedMemoryRanges(device, 1, &range));
1480 }
1481
1482 VkImageAspectFlagBits getPrimaryImageAspect (tcu::TextureFormat::ChannelOrder order)
1483 {
1484         DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
1485
1486         switch (order)
1487         {
1488                 case tcu::TextureFormat::D:
1489                 case tcu::TextureFormat::DS:
1490                         return VK_IMAGE_ASPECT_DEPTH_BIT;
1491
1492                 case tcu::TextureFormat::S:
1493                         return VK_IMAGE_ASPECT_STENCIL_BIT;
1494
1495                 default:
1496                         return VK_IMAGE_ASPECT_COLOR_BIT;
1497         }
1498 }
1499
1500 class RenderQuad
1501 {
1502 public:
1503                                         RenderQuad                      (const Vec2& posA, const Vec2& posB)
1504                 : m_vertices(6)
1505         {
1506                 m_vertices[0] = posA;
1507                 m_vertices[1] = Vec2(posA[0], posB[1]);
1508                 m_vertices[2] = posB;
1509
1510                 m_vertices[3] = posB;
1511                 m_vertices[4] = Vec2(posB[0], posA[1]);
1512                 m_vertices[5] = posA;
1513         }
1514
1515         const Vec2&             getCornerA                      (void) const
1516         {
1517                 return m_vertices[0];
1518         }
1519
1520         const Vec2&             getCornerB                      (void) const
1521         {
1522                 return m_vertices[2];
1523         }
1524
1525         const void*             getVertexPointer        (void) const
1526         {
1527                 return &m_vertices[0];
1528         }
1529
1530         size_t                  getVertexDataSize       (void) const
1531         {
1532                 return sizeof(Vec2) * m_vertices.size();
1533         }
1534
1535 private:
1536         vector<Vec2>    m_vertices;
1537 };
1538
1539 class ColorClear
1540 {
1541 public:
1542                                                                 ColorClear      (const UVec2&                           offset,
1543                                                                                          const UVec2&                           size,
1544                                                                                          const VkClearColorValue&       color)
1545                 : m_offset      (offset)
1546                 , m_size        (size)
1547                 , m_color       (color)
1548         {
1549         }
1550
1551         const UVec2&                            getOffset       (void) const { return m_offset; }
1552         const UVec2&                            getSize         (void) const { return m_size;   }
1553         const VkClearColorValue&        getColor        (void) const { return m_color;  }
1554
1555 private:
1556         UVec2                                           m_offset;
1557         UVec2                                           m_size;
1558         VkClearColorValue                       m_color;
1559 };
1560
1561 class DepthStencilClear
1562 {
1563 public:
1564                                         DepthStencilClear       (const UVec2&   offset,
1565                                                                                  const UVec2&   size,
1566                                                                                  float                  depth,
1567                                                                                  deUint32               stencil)
1568                 : m_offset      (offset)
1569                 , m_size        (size)
1570                 , m_depth       (depth)
1571                 , m_stencil     (stencil)
1572         {
1573         }
1574
1575         const UVec2&    getOffset                       (void) const { return m_offset;         }
1576         const UVec2&    getSize                         (void) const { return m_size;           }
1577         float                   getDepth                        (void) const { return m_depth;          }
1578         deUint32                getStencil                      (void) const { return m_stencil;        }
1579
1580 private:
1581         const UVec2             m_offset;
1582         const UVec2             m_size;
1583
1584         const float             m_depth;
1585         const deUint32  m_stencil;
1586 };
1587
1588 class SubpassRenderInfo
1589 {
1590 public:
1591                                                                         SubpassRenderInfo                               (const RenderPass&                                      renderPass,
1592                                                                                                                                          deUint32                                                       subpassIndex,
1593
1594                                                                                                                                          bool                                                           isSecondary_,
1595
1596                                                                                                                                          const UVec2&                                           viewportOffset,
1597                                                                                                                                          const UVec2&                                           viewportSize,
1598
1599                                                                                                                                          const Maybe<RenderQuad>&                       renderQuad,
1600                                                                                                                                          const vector<ColorClear>&                      colorClears,
1601                                                                                                                                          const Maybe<DepthStencilClear>&        depthStencilClear)
1602                 : m_viewportOffset              (viewportOffset)
1603                 , m_viewportSize                (viewportSize)
1604                 , m_subpassIndex                (subpassIndex)
1605                 , m_isSecondary                 (isSecondary_)
1606                 , m_flags                               (renderPass.getSubpasses()[subpassIndex].getFlags())
1607                 , m_renderQuad                  (renderQuad)
1608                 , m_colorClears                 (colorClears)
1609                 , m_depthStencilClear   (depthStencilClear)
1610                 , m_colorAttachments    (renderPass.getSubpasses()[subpassIndex].getColorAttachments())
1611                 , m_inputAttachments    (renderPass.getSubpasses()[subpassIndex].getInputAttachments())
1612         {
1613                 for (deUint32 attachmentNdx = 0; attachmentNdx < (deUint32)m_colorAttachments.size(); attachmentNdx++)
1614                         m_colorAttachmentInfo.push_back(renderPass.getAttachments()[m_colorAttachments[attachmentNdx].getAttachment()]);
1615
1616                 if (renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
1617                 {
1618                         m_depthStencilAttachment                = tcu::just(renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment());
1619                         m_depthStencilAttachmentInfo    = tcu::just(renderPass.getAttachments()[renderPass.getSubpasses()[subpassIndex].getDepthStencilAttachment().getAttachment()]);
1620                 }
1621         }
1622
1623         const UVec2&                                    getViewportOffset                               (void) const { return m_viewportOffset;         }
1624         const UVec2&                                    getViewportSize                                 (void) const { return m_viewportSize;           }
1625
1626         deUint32                                                getSubpassIndex                                 (void) const { return m_subpassIndex;           }
1627         bool                                                    isSecondary                                             (void) const { return m_isSecondary;            }
1628
1629         const Maybe<RenderQuad>&                getRenderQuad                                   (void) const { return m_renderQuad;                     }
1630         const vector<ColorClear>&               getColorClears                                  (void) const { return m_colorClears;            }
1631         const Maybe<DepthStencilClear>& getDepthStencilClear                    (void) const { return m_depthStencilClear;      }
1632
1633         deUint32                                                getInputAttachmentCount                 (void) const { return (deUint32)m_inputAttachments.size(); }
1634         deUint32                                                getInputAttachmentIndex                 (deUint32 attachmentNdx) const { return m_inputAttachments[attachmentNdx].getAttachment(); }
1635         VkImageLayout                                   getInputAttachmentLayout                (deUint32 attachmentNdx) const { return m_inputAttachments[attachmentNdx].getImageLayout(); }
1636
1637         deUint32                                                getColorAttachmentCount                 (void) const { return (deUint32)m_colorAttachments.size(); }
1638         VkImageLayout                                   getColorAttachmentLayout                (deUint32 attachmentNdx) const { return m_colorAttachments[attachmentNdx].getImageLayout(); }
1639         deUint32                                                getColorAttachmentIndex                 (deUint32 attachmentNdx) const { return m_colorAttachments[attachmentNdx].getAttachment(); }
1640         const Attachment&                               getColorAttachment                              (deUint32 attachmentNdx) const { return m_colorAttachmentInfo[attachmentNdx]; }
1641         Maybe<VkImageLayout>                    getDepthStencilAttachmentLayout (void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getImageLayout()) : tcu::nothing<VkImageLayout>(); }
1642         Maybe<deUint32>                                 getDepthStencilAttachmentIndex  (void) const { return m_depthStencilAttachment ? tcu::just(m_depthStencilAttachment->getAttachment()) : tcu::nothing<deUint32>(); };
1643         const Maybe<Attachment>&                getDepthStencilAttachment               (void) const { return m_depthStencilAttachmentInfo; }
1644         VkSubpassDescriptionFlags               getSubpassFlags                                 (void) const { return m_flags; }
1645
1646 private:
1647         UVec2                                                   m_viewportOffset;
1648         UVec2                                                   m_viewportSize;
1649
1650         deUint32                                                m_subpassIndex;
1651         bool                                                    m_isSecondary;
1652         VkSubpassDescriptionFlags               m_flags;
1653
1654         Maybe<RenderQuad>                               m_renderQuad;
1655         vector<ColorClear>                              m_colorClears;
1656         Maybe<DepthStencilClear>                m_depthStencilClear;
1657
1658         vector<AttachmentReference>             m_colorAttachments;
1659         vector<Attachment>                              m_colorAttachmentInfo;
1660
1661         Maybe<AttachmentReference>              m_depthStencilAttachment;
1662         Maybe<Attachment>                               m_depthStencilAttachmentInfo;
1663
1664         vector<AttachmentReference>             m_inputAttachments;
1665 };
1666
1667 Move<VkPipeline> createSubpassPipeline (const DeviceInterface&          vk,
1668                                                                                 VkDevice                                        device,
1669                                                                                 VkRenderPass                            renderPass,
1670                                                                                 VkShaderModule                          vertexShaderModule,
1671                                                                                 VkShaderModule                          fragmentShaderModule,
1672                                                                                 VkPipelineLayout                        pipelineLayout,
1673                                                                                 const SubpassRenderInfo&        renderInfo)
1674 {
1675         const VkSpecializationInfo emptyShaderSpecializations =
1676         {
1677                 0u,                     // mapEntryCount
1678                 DE_NULL,        // pMap
1679                 0u,                     // dataSize
1680                 DE_NULL,        // pData
1681         };
1682
1683         Maybe<VkSampleCountFlagBits>                            rasterSamples;
1684         vector<VkPipelineColorBlendAttachmentState>     attachmentBlendStates;
1685
1686         for (deUint32 attachmentNdx = 0; attachmentNdx < renderInfo.getColorAttachmentCount(); attachmentNdx++)
1687         {
1688                 const Attachment&       attachment      = renderInfo.getColorAttachment(attachmentNdx);
1689
1690                 DE_ASSERT(!rasterSamples || *rasterSamples == attachment.getSamples());
1691
1692                 rasterSamples = attachment.getSamples();
1693
1694                 {
1695                         const VkPipelineColorBlendAttachmentState       attachmentBlendState =
1696                         {
1697                                 VK_FALSE,                                                                                                                                                                                               // blendEnable
1698                                 VK_BLEND_FACTOR_SRC_ALPHA,                                                                                                                                                              // srcBlendColor
1699                                 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,                                                                                                                                    // destBlendColor
1700                                 VK_BLEND_OP_ADD,                                                                                                                                                                                // blendOpColor
1701                                 VK_BLEND_FACTOR_ONE,                                                                                                                                                                    // srcBlendAlpha
1702                                 VK_BLEND_FACTOR_ONE,                                                                                                                                                                    // destBlendAlpha
1703                                 VK_BLEND_OP_ADD,                                                                                                                                                                                // blendOpAlpha
1704                                 VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT,    // channelWriteMask
1705                         };
1706
1707                         attachmentBlendStates.push_back(attachmentBlendState);
1708                 }
1709         }
1710
1711         if (renderInfo.getDepthStencilAttachment())
1712         {
1713                 const Attachment& attachment = *renderInfo.getDepthStencilAttachment();
1714
1715                 DE_ASSERT(!rasterSamples || *rasterSamples == attachment.getSamples());
1716                 rasterSamples = attachment.getSamples();
1717         }
1718
1719         // If there are no attachment use single sample
1720         if (!rasterSamples)
1721                 rasterSamples = VK_SAMPLE_COUNT_1_BIT;
1722
1723         const VkPipelineShaderStageCreateInfo shaderStages[2] =
1724         {
1725                 {
1726                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // sType
1727                         DE_NULL,                                                                                                // pNext
1728                         (VkPipelineShaderStageCreateFlags)0u,
1729                         VK_SHADER_STAGE_VERTEX_BIT,                                                             // stage
1730                         vertexShaderModule,                                                                             // shader
1731                         "main",
1732                         &emptyShaderSpecializations
1733                 },
1734                 {
1735                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // sType
1736                         DE_NULL,                                                                                                // pNext
1737                         (VkPipelineShaderStageCreateFlags)0u,
1738                         VK_SHADER_STAGE_FRAGMENT_BIT,                                                   // stage
1739                         fragmentShaderModule,                                                                   // shader
1740                         "main",
1741                         &emptyShaderSpecializations
1742                 }
1743         };
1744         const VkVertexInputBindingDescription vertexBinding =
1745         {
1746                 0u,                                                                                                                     // binding
1747                 (deUint32)sizeof(tcu::Vec2),                                                            // strideInBytes
1748                 VK_VERTEX_INPUT_RATE_VERTEX,                                                            // stepRate
1749         };
1750         const VkVertexInputAttributeDescription vertexAttrib =
1751         {
1752                 0u,                                                                                                                     // location
1753                 0u,                                                                                                                     // binding
1754                 VK_FORMAT_R32G32_SFLOAT,                                                                        // format
1755                 0u,                                                                                                                     // offsetInBytes
1756         };
1757         const VkPipelineVertexInputStateCreateInfo vertexInputState =
1758         {
1759                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      //      sType
1760                 DE_NULL,                                                                                                        //      pNext
1761                 (VkPipelineVertexInputStateCreateFlags)0u,
1762                 1u,                                                                                                                     //      bindingCount
1763                 &vertexBinding,                                                                                         //      pVertexBindingDescriptions
1764                 1u,                                                                                                                     //      attributeCount
1765                 &vertexAttrib,                                                                                          //      pVertexAttributeDescriptions
1766         };
1767         const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
1768         {
1769                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // sType
1770                 DE_NULL,                                                                                                                // pNext
1771                 (VkPipelineInputAssemblyStateCreateFlags)0u,
1772                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                                                    // topology
1773                 VK_FALSE,                                                                                                               // primitiveRestartEnable
1774         };
1775         const VkViewport viewport =
1776         {
1777                 (float)renderInfo.getViewportOffset().x(),      (float)renderInfo.getViewportOffset().y(),
1778                 (float)renderInfo.getViewportSize().x(),        (float)renderInfo.getViewportSize().y(),
1779                 0.0f, 1.0f
1780         };
1781         const VkRect2D scissor =
1782         {
1783                 { (deInt32)renderInfo.getViewportOffset().x(),  (deInt32)renderInfo.getViewportOffset().y() },
1784                 { renderInfo.getViewportSize().x(),                             renderInfo.getViewportSize().y() }
1785         };
1786         const VkPipelineViewportStateCreateInfo viewportState =
1787         {
1788                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
1789                 DE_NULL,
1790                 (VkPipelineViewportStateCreateFlags)0u,
1791                 1u,
1792                 &viewport,
1793                 1u,
1794                 &scissor
1795         };
1796         const VkPipelineRasterizationStateCreateInfo rasterState =
1797         {
1798                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,             // sType
1799                 DE_NULL,                                                                                                                // pNext
1800                 (VkPipelineRasterizationStateCreateFlags)0u,
1801                 VK_TRUE,                                                                                                                // depthClipEnable
1802                 VK_FALSE,                                                                                                               // rasterizerDiscardEnable
1803                 VK_POLYGON_MODE_FILL,                                                                                   // fillMode
1804                 VK_CULL_MODE_NONE,                                                                                              // cullMode
1805                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                                                // frontFace
1806                 VK_FALSE,                                                                                                               // depthBiasEnable
1807                 0.0f,                                                                                                                   // depthBias
1808                 0.0f,                                                                                                                   // depthBiasClamp
1809                 0.0f,                                                                                                                   // slopeScaledDepthBias
1810                 1.0f                                                                                                                    // lineWidth
1811         };
1812         const VkPipelineMultisampleStateCreateInfo multisampleState =
1813         {
1814                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,               // sType
1815                 DE_NULL,                                                                                                                // pNext
1816                 (VkPipelineMultisampleStateCreateFlags)0u,
1817                 *rasterSamples,                                                                                                 // rasterSamples
1818                 VK_FALSE,                                                                                                               // sampleShadingEnable
1819                 0.0f,                                                                                                                   // minSampleShading
1820                 DE_NULL,                                                                                                                // pSampleMask
1821                 VK_FALSE,                                                                                                               // alphaToCoverageEnable
1822                 VK_FALSE,                                                                                                               // alphaToOneEnable
1823         };
1824         const size_t    stencilIndex    = renderInfo.getSubpassIndex();
1825         const VkBool32  writeDepth              = renderInfo.getDepthStencilAttachmentLayout()
1826                                                                                 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
1827                                                                                 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
1828                                                                         ? VK_TRUE
1829                                                                         : VK_FALSE;
1830         const VkBool32  writeStencil    = renderInfo.getDepthStencilAttachmentLayout()
1831                                                                                 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
1832                                                                                 && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
1833                                                                         ? VK_TRUE
1834                                                                         : VK_FALSE;
1835         const VkPipelineDepthStencilStateCreateInfo depthStencilState =
1836         {
1837                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,     // sType
1838                 DE_NULL,                                                                                                        // pNext
1839                 (VkPipelineDepthStencilStateCreateFlags)0u,
1840                 writeDepth,                                                                                                     // depthTestEnable
1841                 writeDepth,                                                                                                     // depthWriteEnable
1842                 VK_COMPARE_OP_ALWAYS,                                                                           // depthCompareOp
1843                 VK_FALSE,                                                                                                       // depthBoundsEnable
1844                 writeStencil,                                                                                           // stencilTestEnable
1845                 {
1846                         VK_STENCIL_OP_REPLACE,                                                                  // stencilFailOp
1847                         VK_STENCIL_OP_REPLACE,                                                                  // stencilPassOp
1848                         VK_STENCIL_OP_REPLACE,                                                                  // stencilDepthFailOp
1849                         VK_COMPARE_OP_ALWAYS,                                                                   // stencilCompareOp
1850                         ~0u,                                                                                                    // stencilCompareMask
1851                         ~0u,                                                                                                    // stencilWriteMask
1852                         ((stencilIndex % 2) == 0) ? ~0x0u : 0x0u                                // stencilReference
1853                 },                                                                                                                      // front
1854                 {
1855                         VK_STENCIL_OP_REPLACE,                                                                  // stencilFailOp
1856                         VK_STENCIL_OP_REPLACE,                                                                  // stencilPassOp
1857                         VK_STENCIL_OP_REPLACE,                                                                  // stencilDepthFailOp
1858                         VK_COMPARE_OP_ALWAYS,                                                                   // stencilCompareOp
1859                         ~0u,                                                                                                    // stencilCompareMask
1860                         ~0u,                                                                                                    // stencilWriteMask
1861                         ((stencilIndex % 2) == 0) ? ~0x0u : 0x0u                                // stencilReference
1862                 },                                                                                                                      // back
1863
1864                 0.0f,                                                                                                           // minDepthBounds;
1865                 1.0f                                                                                                            // maxDepthBounds;
1866         };
1867         const VkPipelineColorBlendStateCreateInfo blendState =
1868         {
1869                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,                       // sType
1870                 DE_NULL,                                                                                                                        // pNext
1871                 (VkPipelineColorBlendStateCreateFlags)0u,
1872                 VK_FALSE,                                                                                                                       // logicOpEnable
1873                 VK_LOGIC_OP_COPY,                                                                                                       // logicOp
1874                 (deUint32)attachmentBlendStates.size(),                                                         // attachmentCount
1875                 attachmentBlendStates.empty() ? DE_NULL : &attachmentBlendStates[0],// pAttachments
1876                 { 0.0f, 0.0f, 0.0f, 0.0f }                                                                                      // blendConst
1877         };
1878         const VkGraphicsPipelineCreateInfo createInfo =
1879         {
1880                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,        // sType
1881                 DE_NULL,                                                                                        // pNext
1882                 (VkPipelineCreateFlags)0u,
1883
1884                 2,                                                                                                      // stageCount
1885                 shaderStages,                                                                           // pStages
1886
1887                 &vertexInputState,                                                                      // pVertexInputState
1888                 &inputAssemblyState,                                                            // pInputAssemblyState
1889                 DE_NULL,                                                                                        // pTessellationState
1890                 &viewportState,                                                                         // pViewportState
1891                 &rasterState,                                                                           // pRasterState
1892                 &multisampleState,                                                                      // pMultisampleState
1893                 &depthStencilState,                                                                     // pDepthStencilState
1894                 &blendState,                                                                            // pColorBlendState
1895                 (const VkPipelineDynamicStateCreateInfo*)DE_NULL,       // pDynamicState
1896                 pipelineLayout,                                                                         // layout
1897
1898                 renderPass,                                                                                     // renderPass
1899                 renderInfo.getSubpassIndex(),                                           // subpass
1900                 DE_NULL,                                                                                        // basePipelineHandle
1901                 0u                                                                                                      // basePipelineIndex
1902         };
1903
1904         return createGraphicsPipeline(vk, device, DE_NULL, &createInfo);
1905 }
1906
1907 class SubpassRenderer
1908 {
1909 public:
1910         SubpassRenderer (Context&                                                                               context,
1911                                          const DeviceInterface&                                                 vk,
1912                                          VkDevice                                                                               device,
1913                                          Allocator&                                                                             allocator,
1914                                          VkRenderPass                                                                   renderPass,
1915                                          VkFramebuffer                                                                  framebuffer,
1916                                          VkCommandPool                                                                  commandBufferPool,
1917                                          deUint32                                                                               queueFamilyIndex,
1918                                          const vector<VkImage>&                                                 attachmentImages,
1919                                          const vector<pair<VkImageView, VkImageView> >& attachmentViews,
1920                                          const SubpassRenderInfo&                                               renderInfo,
1921                                          const vector<Attachment>&                                              attachmentInfos,
1922                                          const AllocationKind                                                   allocationKind)
1923                 : m_renderInfo  (renderInfo)
1924         {
1925                 const InstanceInterface&                                vki                             = context.getInstanceInterface();
1926                 const VkPhysicalDevice&                                 physDevice              = context.getPhysicalDevice();
1927                 const deUint32                                                  subpassIndex    = renderInfo.getSubpassIndex();
1928                 vector<VkDescriptorSetLayoutBinding>    bindings;
1929
1930                 for (deUint32 colorAttachmentNdx = 0; colorAttachmentNdx < renderInfo.getColorAttachmentCount();  colorAttachmentNdx++)
1931                         m_colorAttachmentImages.push_back(attachmentImages[renderInfo.getColorAttachmentIndex(colorAttachmentNdx)]);
1932
1933                 if (renderInfo.getDepthStencilAttachmentIndex())
1934                         m_depthStencilAttachmentImage = attachmentImages[*renderInfo.getDepthStencilAttachmentIndex()];
1935
1936                 if (renderInfo.getRenderQuad())
1937                 {
1938                         const RenderQuad&       renderQuad      = *renderInfo.getRenderQuad();
1939
1940                         if (renderInfo.getInputAttachmentCount() > 0)
1941                         {
1942                                 deUint32                                                                bindingIndex    = 0;
1943
1944                                 for (deUint32 inputAttachmentNdx = 0; inputAttachmentNdx < renderInfo.getInputAttachmentCount(); inputAttachmentNdx++)
1945                                 {
1946                                         const Attachment                        attachmentInfo  = attachmentInfos[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)];
1947                                         const VkImageLayout                     layout                  = renderInfo.getInputAttachmentLayout(inputAttachmentNdx);
1948                                         const tcu::TextureFormat        format                  = mapVkFormat(attachmentInfo.getFormat());
1949                                         const bool                                      isDepthFormat   = tcu::hasDepthComponent(format.order);
1950                                         const bool                                      isStencilFormat = tcu::hasStencilComponent(format.order);
1951                                         const deUint32                          bindingCount    = (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
1952                                                                                                                                         && (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
1953                                                                                                                                 ? 2u
1954                                                                                                                                 : 1u;
1955
1956                                         for (deUint32 bindingNdx = 0; bindingNdx < bindingCount; bindingNdx++)
1957                                         {
1958                                                 const VkDescriptorSetLayoutBinding binding =
1959                                                 {
1960                                                         bindingIndex,
1961                                                         vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
1962                                                         1u,
1963                                                         vk::VK_SHADER_STAGE_FRAGMENT_BIT,
1964                                                         DE_NULL
1965                                                 };
1966
1967                                                 bindings.push_back(binding);
1968                                                 bindingIndex++;
1969                                         }
1970                                 }
1971
1972                                 const VkDescriptorSetLayoutCreateInfo createInfo =
1973                                 {
1974                                         vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
1975                                         DE_NULL,
1976
1977                                         0u,
1978                                         (deUint32)bindings.size(),
1979                                         &bindings[0]
1980                                 };
1981
1982                                 m_descriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &createInfo);
1983                         }
1984
1985                         const VkDescriptorSetLayout                     descriptorSetLayout             = *m_descriptorSetLayout;
1986                         const VkPipelineLayoutCreateInfo        pipelineLayoutParams    =
1987                         {
1988                                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                  // sType;
1989                                 DE_NULL,                                                                                                // pNext;
1990                                 (vk::VkPipelineLayoutCreateFlags)0,
1991                                 m_descriptorSetLayout ? 1u :0u ,                                                // setLayoutCount;
1992                                 m_descriptorSetLayout ? &descriptorSetLayout : DE_NULL, // pSetLayouts;
1993                                 0u,                                                                                                             // pushConstantRangeCount;
1994                                 DE_NULL,                                                                                                // pPushConstantRanges;
1995                         };
1996
1997                         m_vertexShaderModule    = createShaderModule(vk, device, context.getBinaryCollection().get(de::toString(subpassIndex) + "-vert"), 0u);
1998                         m_fragmentShaderModule  = createShaderModule(vk, device, context.getBinaryCollection().get(de::toString(subpassIndex) + "-frag"), 0u);
1999                         m_pipelineLayout                = createPipelineLayout(vk, device, &pipelineLayoutParams);
2000                         m_pipeline                              = createSubpassPipeline(vk, device, renderPass, *m_vertexShaderModule, *m_fragmentShaderModule, *m_pipelineLayout, m_renderInfo);
2001
2002                         m_vertexBuffer                  = createBuffer(vk, device, 0u, (VkDeviceSize)renderQuad.getVertexDataSize(), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_SHARING_MODE_EXCLUSIVE, 1u, &queueFamilyIndex);
2003                         m_vertexBufferMemory    = allocateBuffer(vki, vk, physDevice, device, *m_vertexBuffer, MemoryRequirement::HostVisible, allocator, allocationKind);
2004
2005                         bindBufferMemory(vk, device, *m_vertexBuffer, m_vertexBufferMemory->getMemory(), m_vertexBufferMemory->getOffset());
2006                         uploadBufferData(vk, device, *m_vertexBufferMemory, renderQuad.getVertexDataSize(), renderQuad.getVertexPointer());
2007
2008                         if (renderInfo.getInputAttachmentCount() > 0)
2009                         {
2010                                 {
2011                                         const VkDescriptorPoolSize poolSize =
2012                                         {
2013                                                 vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2014                                                 // \note Reserve 2 per input attachment since depthStencil attachments require 2.
2015                                                 renderInfo.getInputAttachmentCount() * 2u
2016                                         };
2017                                         const VkDescriptorPoolCreateInfo createInfo =
2018                                         {
2019                                                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2020                                                 DE_NULL,
2021                                                 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
2022
2023                                                 // \note Reserve 2 per input attachment since depthStencil attachments require 2.
2024                                                 renderInfo.getInputAttachmentCount() * 2u,
2025                                                 1u,
2026                                                 &poolSize
2027                                         };
2028
2029                                         m_descriptorPool = vk::createDescriptorPool(vk, device, &createInfo);
2030                                 }
2031                                 {
2032                                         const VkDescriptorSetAllocateInfo       allocateInfo =
2033                                         {
2034                                                 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2035                                                 DE_NULL,
2036
2037                                                 *m_descriptorPool,
2038                                                 1u,
2039                                                 &descriptorSetLayout
2040                                         };
2041
2042                                         m_descriptorSet = vk::allocateDescriptorSet(vk, device, &allocateInfo);
2043                                 }
2044                                 {
2045                                         vector<VkWriteDescriptorSet>    writes                  (bindings.size());
2046                                         vector<VkDescriptorImageInfo>   imageInfos              (bindings.size());
2047                                         deUint32                                                bindingIndex    = 0;
2048
2049                                         for (deUint32 inputAttachmentNdx = 0; inputAttachmentNdx < renderInfo.getInputAttachmentCount(); inputAttachmentNdx++)
2050                                         {
2051                                                 const Attachment                        attachmentInfo                  = attachmentInfos[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)];
2052                                                 const tcu::TextureFormat        format                                  = mapVkFormat(attachmentInfo.getFormat());
2053                                                 const bool                                      isDepthFormat                   = tcu::hasDepthComponent(format.order);
2054                                                 const bool                                      isStencilFormat                 = tcu::hasStencilComponent(format.order);
2055                                                 const VkImageLayout                     inputAttachmentLayout   = renderInfo.getInputAttachmentLayout(inputAttachmentNdx);
2056
2057
2058                                                 if (isDepthFormat && isStencilFormat)
2059                                                 {
2060                                                         if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
2061                                                         {
2062                                                                 const VkDescriptorImageInfo     imageInfo =
2063                                                                 {
2064                                                                         (VkSampler)0,
2065                                                                         attachmentViews[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)].first,
2066                                                                         inputAttachmentLayout
2067                                                                 };
2068                                                                 imageInfos[bindingIndex] = imageInfo;
2069
2070                                                                 {
2071                                                                         const VkWriteDescriptorSet      write =
2072                                                                         {
2073                                                                                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2074                                                                                 DE_NULL,
2075
2076                                                                                 *m_descriptorSet,
2077                                                                                 bindingIndex,
2078                                                                                 0u,
2079                                                                                 1u,
2080                                                                                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2081                                                                                 &imageInfos[bindingIndex],
2082                                                                                 DE_NULL,
2083                                                                                 DE_NULL
2084                                                                         };
2085                                                                         writes[bindingIndex] = write;
2086
2087                                                                         bindingIndex++;
2088                                                                 }
2089                                                         }
2090
2091                                                         if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
2092                                                         {
2093                                                                 const VkDescriptorImageInfo     imageInfo =
2094                                                                 {
2095                                                                         (VkSampler)0,
2096                                                                         attachmentViews[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)].second,
2097                                                                         inputAttachmentLayout
2098                                                                 };
2099                                                                 imageInfos[bindingIndex] = imageInfo;
2100
2101                                                                 {
2102                                                                         const VkWriteDescriptorSet      write =
2103                                                                         {
2104                                                                                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2105                                                                                 DE_NULL,
2106
2107                                                                                 *m_descriptorSet,
2108                                                                                 bindingIndex,
2109                                                                                 0u,
2110                                                                                 1u,
2111                                                                                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2112                                                                                 &imageInfos[bindingIndex],
2113                                                                                 DE_NULL,
2114                                                                                 DE_NULL
2115                                                                         };
2116                                                                         writes[bindingIndex] = write;
2117
2118                                                                         bindingIndex++;
2119                                                                 }
2120                                                         }
2121                                                 }
2122                                                 else
2123                                                 {
2124                                                         const VkDescriptorImageInfo     imageInfo =
2125                                                         {
2126                                                                 (VkSampler)0,
2127                                                                 attachmentViews[renderInfo.getInputAttachmentIndex(inputAttachmentNdx)].first,
2128                                                                 inputAttachmentLayout
2129                                                         };
2130                                                         imageInfos[bindingIndex] = imageInfo;
2131
2132                                                         {
2133                                                                 const VkWriteDescriptorSet      write =
2134                                                                 {
2135                                                                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
2136                                                                         DE_NULL,
2137
2138                                                                         *m_descriptorSet,
2139                                                                         bindingIndex,
2140                                                                         0u,
2141                                                                         1u,
2142                                                                         VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2143                                                                         &imageInfos[bindingIndex],
2144                                                                         DE_NULL,
2145                                                                         DE_NULL
2146                                                                 };
2147                                                                 writes[bindingIndex] = write;
2148
2149                                                                 bindingIndex++;
2150                                                         }
2151                                                 }
2152                                         }
2153
2154                                         vk.updateDescriptorSets(device, (deUint32)writes.size(), &writes[0], 0u, DE_NULL);
2155                                 }
2156                         }
2157                 }
2158
2159                 if (renderInfo.isSecondary())
2160                 {
2161                         m_commandBuffer = allocateCommandBuffer(vk, device, commandBufferPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
2162
2163                         beginCommandBuffer(vk, *m_commandBuffer, vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, renderPass, subpassIndex, framebuffer, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
2164                         pushRenderCommands(vk, *m_commandBuffer);
2165                         endCommandBuffer(vk, *m_commandBuffer);
2166                 }
2167         }
2168
2169         bool isSecondary (void) const
2170         {
2171                 return m_commandBuffer;
2172         }
2173
2174         VkCommandBuffer getCommandBuffer (void) const
2175         {
2176                 DE_ASSERT(isSecondary());
2177                 return *m_commandBuffer;
2178         }
2179
2180         void pushRenderCommands (const DeviceInterface&         vk,
2181                                                          VkCommandBuffer                        commandBuffer)
2182         {
2183                 if (!m_renderInfo.getColorClears().empty())
2184                 {
2185                         const vector<ColorClear>&       colorClears     (m_renderInfo.getColorClears());
2186
2187                         for (deUint32 attachmentNdx = 0; attachmentNdx < m_renderInfo.getColorAttachmentCount(); attachmentNdx++)
2188                         {
2189                                 const ColorClear&               colorClear      = colorClears[attachmentNdx];
2190                                 const VkClearAttachment attachment      =
2191                                 {
2192                                         VK_IMAGE_ASPECT_COLOR_BIT,
2193                                         attachmentNdx,
2194                                         makeClearValue(colorClear.getColor()),
2195                                 };
2196                                 const VkClearRect               rect            =
2197                                 {
2198                                         {
2199                                                 { (deInt32)colorClear.getOffset().x(),  (deInt32)colorClear.getOffset().y()     },
2200                                                 { colorClear.getSize().x(),                             colorClear.getSize().y()                        }
2201                                         },                                      // rect
2202                                         0u,                                     // baseArrayLayer
2203                                         1u,                                     // layerCount
2204                                 };
2205
2206                                 vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
2207                         }
2208                 }
2209
2210                 if (m_renderInfo.getDepthStencilClear())
2211                 {
2212                         const DepthStencilClear&        depthStencilClear       = *m_renderInfo.getDepthStencilClear();
2213                         const deUint32                          attachmentNdx           = m_renderInfo.getColorAttachmentCount();
2214                         tcu::TextureFormat                      format                          = mapVkFormat(m_renderInfo.getDepthStencilAttachment()->getFormat());
2215                         const VkImageLayout                     layout                          = *m_renderInfo.getDepthStencilAttachmentLayout();
2216                         const VkClearAttachment         attachment                      =
2217                         {
2218                                 (VkImageAspectFlags)((hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
2219                                         | (hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
2220                                 attachmentNdx,
2221                                 makeClearValueDepthStencil(depthStencilClear.getDepth(), depthStencilClear.getStencil())
2222                         };
2223                         const VkClearRect                               rect                            =
2224                         {
2225                                 {
2226                                         { (deInt32)depthStencilClear.getOffset().x(),   (deInt32)depthStencilClear.getOffset().y()      },
2227                                         { depthStencilClear.getSize().x(),                              depthStencilClear.getSize().y()                         }
2228                                 },                                                      // rect
2229                                 0u,                                                     // baseArrayLayer
2230                                 1u,                                                     // layerCount
2231                         };
2232
2233                         if ((tcu::hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
2234                                 || (tcu::hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL))
2235                         {
2236                                 vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
2237                         }
2238                 }
2239
2240                 vector<VkImageMemoryBarrier>    selfDeps;
2241                 VkPipelineStageFlags                    srcStages = 0;
2242                 VkPipelineStageFlags                    dstStages = 0;
2243
2244                 for (deUint32 inputAttachmentNdx = 0; inputAttachmentNdx < m_renderInfo.getInputAttachmentCount(); inputAttachmentNdx++)
2245                 {
2246                         for (deUint32 colorAttachmentNdx = 0; colorAttachmentNdx < m_renderInfo.getColorAttachmentCount(); colorAttachmentNdx++)
2247                         {
2248                                 if (m_renderInfo.getInputAttachmentIndex(inputAttachmentNdx) == m_renderInfo.getColorAttachmentIndex(colorAttachmentNdx))
2249                                 {
2250                                         const VkImageMemoryBarrier      barrier   =
2251                                         {
2252                                                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // sType
2253                                                 DE_NULL,                                                                                // pNext
2254
2255                                                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                   // srcAccessMask
2256                                                 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,                    // dstAccessMask
2257
2258                                                 VK_IMAGE_LAYOUT_GENERAL,                                                // oldLayout
2259                                                 VK_IMAGE_LAYOUT_GENERAL,                                                // newLayout
2260
2261                                                 VK_QUEUE_FAMILY_IGNORED,                                                // srcQueueFamilyIndex
2262                                                 VK_QUEUE_FAMILY_IGNORED,                                                // destQueueFamilyIndex
2263
2264                                                 m_colorAttachmentImages[colorAttachmentNdx],    // image
2265                                                 {                                                                                               // subresourceRange
2266                                                         VK_IMAGE_ASPECT_COLOR_BIT,                                              // aspect
2267                                                         0,                                                                                              // baseMipLevel
2268                                                         1,                                                                                              // mipLevels
2269                                                         0,                                                                                              // baseArraySlice
2270                                                         1                                                                                               // arraySize
2271                                                 }
2272                                         };
2273
2274                                         srcStages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
2275                                         dstStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
2276
2277                                         selfDeps.push_back(barrier);
2278                                 }
2279                         }
2280
2281                         if (m_renderInfo.getDepthStencilAttachmentIndex() && (m_renderInfo.getInputAttachmentIndex(inputAttachmentNdx) == *m_renderInfo.getDepthStencilAttachmentIndex()))
2282                         {
2283                                 const tcu::TextureFormat        format          = mapVkFormat(m_renderInfo.getDepthStencilAttachment()->getFormat());
2284                                 const bool                                      hasDepth        = hasDepthComponent(format.order);
2285                                 const bool                                      hasStencil      = hasStencilComponent(format.order);
2286                                 const VkImageMemoryBarrier      barrier         =
2287                                 {
2288                                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // sType;
2289                                         DE_NULL,                                                                                // pNext;
2290
2291                                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,   // srcAccessMask
2292                                         VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,                    // dstAccessMask
2293
2294                                         VK_IMAGE_LAYOUT_GENERAL,                                                // oldLayout
2295                                         VK_IMAGE_LAYOUT_GENERAL,                                                // newLayout;
2296
2297                                         VK_QUEUE_FAMILY_IGNORED,                                                // srcQueueFamilyIndex;
2298                                         VK_QUEUE_FAMILY_IGNORED,                                                // destQueueFamilyIndex;
2299
2300                                         m_depthStencilAttachmentImage,                                  // image;
2301                                         {                                                                                               // subresourceRange;
2302                                                 (hasDepth ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
2303                                                         | (hasStencil ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u),  // aspect;
2304                                                 0,                                                                                                                      // baseMipLevel;
2305                                                 1,                                                                                                                      // mipLevels;
2306                                                 0,                                                                                                                      // baseArraySlice;
2307                                                 1                                                                                                                       // arraySize;
2308                                         }
2309                                 };
2310
2311                                 srcStages |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
2312                                 dstStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
2313
2314                                 selfDeps.push_back(barrier);
2315                         }
2316                 }
2317
2318                 if (!selfDeps.empty())
2319                 {
2320                         DE_ASSERT(srcStages != 0);
2321                         DE_ASSERT(dstStages != 0);
2322                         vk.cmdPipelineBarrier(commandBuffer, srcStages, dstStages, VK_DEPENDENCY_BY_REGION_BIT, 0, DE_NULL, 0, DE_NULL, (deUint32)selfDeps.size(), &selfDeps[0]);
2323                 }
2324
2325                 if (m_renderInfo.getRenderQuad())
2326                 {
2327                         const VkDeviceSize      offset                  = 0;
2328                         const VkBuffer          vertexBuffer    = *m_vertexBuffer;
2329
2330                         vk.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
2331
2332                         if (m_descriptorSet)
2333                         {
2334                                 const VkDescriptorSet descriptorSet = *m_descriptorSet;
2335                                 vk.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1u, &descriptorSet, 0u, NULL);
2336                         }
2337
2338                         vk.cmdBindVertexBuffers(commandBuffer, 0u, 1u, &vertexBuffer, &offset);
2339                         vk.cmdDraw(commandBuffer, 6u, 1u, 0u, 0u);
2340                 }
2341         }
2342
2343 private:
2344         const SubpassRenderInfo         m_renderInfo;
2345         Move<VkCommandBuffer>           m_commandBuffer;
2346         Move<VkPipeline>                        m_pipeline;
2347         Move<VkDescriptorSetLayout>     m_descriptorSetLayout;
2348         Move<VkPipelineLayout>          m_pipelineLayout;
2349
2350         Move<VkShaderModule>            m_vertexShaderModule;
2351         Move<VkShaderModule>            m_fragmentShaderModule;
2352
2353         Move<VkDescriptorPool>          m_descriptorPool;
2354         Move<VkDescriptorSet>           m_descriptorSet;
2355         Move<VkBuffer>                          m_vertexBuffer;
2356         de::MovePtr<Allocation>         m_vertexBufferMemory;
2357         vector<VkImage>                         m_colorAttachmentImages;
2358         VkImage                                         m_depthStencilAttachmentImage;
2359 };
2360
2361 void pushImageInitializationCommands (const DeviceInterface&                                                            vk,
2362                                                                           VkCommandBuffer                                                                               commandBuffer,
2363                                                                           const vector<Attachment>&                                                             attachmentInfo,
2364                                                                           const vector<de::SharedPtr<AttachmentResources> >&    attachmentResources,
2365                                                                           deUint32                                                                                              queueIndex,
2366                                                                           const vector<Maybe<VkClearValue> >&                                   clearValues)
2367 {
2368         {
2369                 vector<VkImageMemoryBarrier>    initializeLayouts;
2370
2371                 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2372                 {
2373                         if (!clearValues[attachmentNdx])
2374                                 continue;
2375
2376                         const VkImageMemoryBarrier barrier =
2377                         {
2378                                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                                                 // sType;
2379                                 DE_NULL,                                                                                                                // pNext;
2380
2381                                 (VkAccessFlags)0,                                                                                               // srcAccessMask
2382                                 getAllMemoryReadFlags() | VK_ACCESS_TRANSFER_WRITE_BIT,                 // dstAccessMask
2383
2384                                 VK_IMAGE_LAYOUT_UNDEFINED,                                                                              // oldLayout
2385                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                                                   // newLayout;
2386
2387                                 queueIndex,                                                                                                             // srcQueueFamilyIndex;
2388                                 queueIndex,                                                                                                             // destQueueFamilyIndex;
2389
2390                                 attachmentResources[attachmentNdx]->getImage(),                                 // image;
2391                                 {                                                                                                                               // subresourceRange;
2392                                         getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),         // aspect;
2393                                         0,                                                                                                                                      // baseMipLevel;
2394                                         1,                                                                                                                                      // mipLevels;
2395                                         0,                                                                                                                                      // baseArraySlice;
2396                                         1                                                                                                                                       // arraySize;
2397                                 }
2398                         };
2399
2400                         initializeLayouts.push_back(barrier);
2401                 }
2402
2403                 if (!initializeLayouts.empty())
2404                         vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
2405                                                                   VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
2406                                                                   0, (const VkMemoryBarrier*)DE_NULL,
2407                                                                   0, (const VkBufferMemoryBarrier*)DE_NULL,
2408                                                                   (deUint32)initializeLayouts.size(), &initializeLayouts[0]);
2409         }
2410
2411         for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2412         {
2413                 if (!clearValues[attachmentNdx])
2414                         continue;
2415
2416                 const tcu::TextureFormat format = mapVkFormat(attachmentInfo[attachmentNdx].getFormat());
2417
2418                 if (hasStencilComponent(format.order) || hasDepthComponent(format.order))
2419                 {
2420                         const float                                             clearNan                = tcu::Float32::nan().asFloat();
2421                         const float                                             clearDepth              = hasDepthComponent(format.order) ? clearValues[attachmentNdx]->depthStencil.depth : clearNan;
2422                         const deUint32                                  clearStencil    = hasStencilComponent(format.order) ? clearValues[attachmentNdx]->depthStencil.stencil : 0xDEu;
2423                         const VkClearDepthStencilValue  depthStencil    =
2424                         {
2425                                 clearDepth,
2426                                 clearStencil
2427                         };
2428                         const VkImageSubresourceRange range =
2429                         {
2430                                 (VkImageAspectFlags)((hasDepthComponent(format.order) ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
2431                                                                          | (hasStencilComponent(format.order) ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
2432                                 0,
2433                                 1,
2434                                 0,
2435                                 1
2436                         };
2437
2438                         vk.cmdClearDepthStencilImage(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &depthStencil, 1, &range);
2439                 }
2440                 else
2441                 {
2442                         const VkImageSubresourceRange   range           =
2443                         {
2444                                 VK_IMAGE_ASPECT_COLOR_BIT,      // aspectMask;
2445                                 0,                                                      // baseMipLevel;
2446                                 1,                                                      // mipLevels;
2447                                 0,                                                      // baseArrayLayer;
2448                                 1                                                       // layerCount;
2449                         };
2450                         const VkClearColorValue                 clearColor      = clearValues[attachmentNdx]->color;
2451
2452                         vk.cmdClearColorImage(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &range);
2453                 }
2454         }
2455
2456         {
2457                 vector<VkImageMemoryBarrier>    renderPassLayouts;
2458
2459                 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2460                 {
2461                         const VkImageLayout                     oldLayout       = clearValues[attachmentNdx] ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
2462                         const VkImageMemoryBarrier      barrier         =
2463                         {
2464                                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                                 // sType;
2465                                 DE_NULL,                                                                                                // pNext;
2466
2467                                 (oldLayout != VK_IMAGE_LAYOUT_UNDEFINED ? getAllMemoryWriteFlags() : (VkAccessFlags)0),                                 // srcAccessMask
2468                                 getAllMemoryReadFlags() | getMemoryFlagsForLayout(attachmentInfo[attachmentNdx].getInitialLayout()),    // dstAccessMask
2469
2470                                 oldLayout,                                                                                              // oldLayout
2471                                 attachmentInfo[attachmentNdx].getInitialLayout(),               // newLayout;
2472
2473                                 queueIndex,                                                                                             // srcQueueFamilyIndex;
2474                                 queueIndex,                                                                                             // destQueueFamilyIndex;
2475
2476                                 attachmentResources[attachmentNdx]->getImage(),                 // image;
2477                                 {                                                                                                               // subresourceRange;
2478                                         getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),         // aspect;
2479                                         0,                                                                                                                                      // baseMipLevel;
2480                                         1,                                                                                                                                      // mipLevels;
2481                                         0,                                                                                                                                      // baseArraySlice;
2482                                         1                                                                                                                                       // arraySize;
2483                                 }
2484                         };
2485
2486                         renderPassLayouts.push_back(barrier);
2487                 }
2488
2489                 if (!renderPassLayouts.empty())
2490                         vk.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
2491                                                                   VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
2492                                                                   0, (const VkMemoryBarrier*)DE_NULL,
2493                                                                   0, (const VkBufferMemoryBarrier*)DE_NULL,
2494                                                                   (deUint32)renderPassLayouts.size(), &renderPassLayouts[0]);
2495         }
2496 }
2497
2498 void pushRenderPassCommands (const DeviceInterface&                                                     vk,
2499                                                          VkCommandBuffer                                                                commandBuffer,
2500                                                          VkRenderPass                                                                   renderPass,
2501                                                          VkFramebuffer                                                                  framebuffer,
2502                                                          const vector<de::SharedPtr<SubpassRenderer> >& subpassRenderers,
2503                                                          const UVec2&                                                                   renderPos,
2504                                                          const UVec2&                                                                   renderSize,
2505                                                          const vector<Maybe<VkClearValue> >&                    renderPassClearValues,
2506                                                          TestConfig::RenderTypes                                                render)
2507 {
2508         const float                             clearNan                                = tcu::Float32::nan().asFloat();
2509         vector<VkClearValue>    attachmentClearValues;
2510
2511         for (size_t attachmentNdx = 0; attachmentNdx < renderPassClearValues.size(); attachmentNdx++)
2512         {
2513                 if (renderPassClearValues[attachmentNdx])
2514                         attachmentClearValues.push_back(*renderPassClearValues[attachmentNdx]);
2515                 else
2516                         attachmentClearValues.push_back(makeClearValueColorF32(clearNan, clearNan, clearNan, clearNan));
2517         }
2518
2519         {
2520                 const VkRect2D renderArea =
2521                 {
2522                         { (deInt32)renderPos.x(),       (deInt32)renderPos.y()  },
2523                         { renderSize.x(),                       renderSize.y()                  }
2524                 };
2525
2526                 for (size_t subpassNdx = 0; subpassNdx < subpassRenderers.size(); subpassNdx++)
2527                 {
2528                         const VkSubpassContents contents = subpassRenderers[subpassNdx]->isSecondary() ? VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS : VK_SUBPASS_CONTENTS_INLINE;
2529
2530                         if (subpassNdx == 0)
2531                                 cmdBeginRenderPass(vk, commandBuffer, renderPass, framebuffer, renderArea, (deUint32)attachmentClearValues.size(), attachmentClearValues.empty() ? DE_NULL : &attachmentClearValues[0], contents);
2532                         else
2533                                 vk.cmdNextSubpass(commandBuffer, contents);
2534
2535                         if (render)
2536                         {
2537                                 if (contents == VK_SUBPASS_CONTENTS_INLINE)
2538                                 {
2539                                         subpassRenderers[subpassNdx]->pushRenderCommands(vk, commandBuffer);
2540                                 }
2541                                 else if (contents == VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS)
2542                                 {
2543                                         const VkCommandBuffer cmd = subpassRenderers[subpassNdx]->getCommandBuffer();
2544                                         vk.cmdExecuteCommands(commandBuffer, 1, &cmd);
2545                                 }
2546                                 else
2547                                         DE_FATAL("Invalid contents");
2548                         }
2549                 }
2550
2551                 vk.cmdEndRenderPass(commandBuffer);
2552         }
2553 }
2554
2555 void pushReadImagesToBuffers (const DeviceInterface&                                                            vk,
2556                                                           VkCommandBuffer                                                                               commandBuffer,
2557                                                           deUint32                                                                                              queueIndex,
2558
2559                                                           const vector<de::SharedPtr<AttachmentResources> >&    attachmentResources,
2560                                                           const vector<Attachment>&                                                             attachmentInfo,
2561                                                           const vector<bool>&                                                                   isLazy,
2562
2563                                                           const UVec2&                                                                                  targetSize)
2564 {
2565         {
2566                 vector<VkImageMemoryBarrier>    imageBarriers;
2567
2568                 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2569                 {
2570                         if (isLazy[attachmentNdx])
2571                                 continue;
2572
2573                         const VkImageLayout                     oldLayout       = attachmentInfo[attachmentNdx].getFinalLayout();
2574                         const VkImageMemoryBarrier      barrier         =
2575                         {
2576                                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                                                 // sType
2577                                 DE_NULL,                                                                                                                // pNext
2578
2579                                 getAllMemoryWriteFlags() | getMemoryFlagsForLayout(oldLayout),  // srcAccessMask
2580                                 getAllMemoryReadFlags(),                                                                                // dstAccessMask
2581
2582                                 oldLayout,                                                                                                              // oldLayout
2583                                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                                                   // newLayout
2584
2585                                 queueIndex,                                                                                                             // srcQueueFamilyIndex
2586                                 queueIndex,                                                                                                             // destQueueFamilyIndex
2587
2588                                 attachmentResources[attachmentNdx]->getImage(),                                 // image
2589                                 {                                                                                                                               // subresourceRange
2590                                         getImageAspectFlags(attachmentInfo[attachmentNdx].getFormat()),         // aspect;
2591                                         0,                                                                                                                                      // baseMipLevel
2592                                         1,                                                                                                                                      // mipLevels
2593                                         0,                                                                                                                                      // baseArraySlice
2594                                         1                                                                                                                                       // arraySize
2595                                 }
2596                         };
2597
2598                         imageBarriers.push_back(barrier);
2599                 }
2600
2601                 if (!imageBarriers.empty())
2602                         vk.cmdPipelineBarrier(commandBuffer,
2603                                                                   getAllPipelineStageFlags(),
2604                                                                   getAllPipelineStageFlags(),
2605                                                                   (VkDependencyFlags)0,
2606                                                                   0, (const VkMemoryBarrier*)DE_NULL,
2607                                                                   0, (const VkBufferMemoryBarrier*)DE_NULL,
2608                                                                   (deUint32)imageBarriers.size(), &imageBarriers[0]);
2609         }
2610
2611         for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2612         {
2613                 if (isLazy[attachmentNdx])
2614                         continue;
2615
2616                 const tcu::TextureFormat::ChannelOrder  order   = mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order;
2617                 const VkBufferImageCopy                                 rect    =
2618                 {
2619                         0, // bufferOffset
2620                         0, // bufferRowLength
2621                         0, // bufferImageHeight
2622                         {                                                       // imageSubresource
2623                                 (vk::VkImageAspectFlags)getPrimaryImageAspect(mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order),    // aspect
2624                                 0,                                              // mipLevel
2625                                 0,                                              // arraySlice
2626                                 1                                               // arraySize
2627                         },
2628                         { 0, 0, 0 },                            // imageOffset
2629                         { targetSize.x(), targetSize.y(), 1u }          // imageExtent
2630                 };
2631
2632                 vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getBuffer(), 1, &rect);
2633
2634                 if (tcu::TextureFormat::DS == order)
2635                 {
2636                         const VkBufferImageCopy stencilRect =
2637                         {
2638                                 0,                                                                              // bufferOffset
2639                                 0,                                                                              // bufferRowLength
2640                                 0,                                                                              // bufferImageHeight
2641                                 {                                                                       // imageSubresource
2642                                         VK_IMAGE_ASPECT_STENCIL_BIT,    // aspect
2643                                         0,                                                              // mipLevel
2644                                         0,                                                              // arraySlice
2645                                         1                                                               // arraySize
2646                                 },
2647                                 { 0, 0, 0 },                                                    // imageOffset
2648                                 { targetSize.x(), targetSize.y(), 1u }  // imageExtent
2649                         };
2650
2651                         vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getSecondaryBuffer(), 1, &stencilRect);
2652                 }
2653         }
2654
2655         {
2656                 vector<VkBufferMemoryBarrier>   bufferBarriers;
2657
2658                 for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
2659                 {
2660                         if (isLazy[attachmentNdx])
2661                                 continue;
2662
2663                         const tcu::TextureFormat::ChannelOrder  order                   = mapVkFormat(attachmentInfo[attachmentNdx].getFormat()).order;
2664                         const VkBufferMemoryBarrier                             bufferBarrier   =
2665                         {
2666                                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
2667                                 DE_NULL,
2668
2669                                 getAllMemoryWriteFlags(),
2670                                 getAllMemoryReadFlags(),
2671
2672                                 queueIndex,
2673                                 queueIndex,
2674
2675                                 attachmentResources[attachmentNdx]->getBuffer(),
2676                                 0,
2677                                 attachmentResources[attachmentNdx]->getBufferSize()
2678                         };
2679
2680                         bufferBarriers.push_back(bufferBarrier);
2681
2682                         if (tcu::TextureFormat::DS == order)
2683                         {
2684                                 const VkBufferMemoryBarrier secondaryBufferBarrier =
2685                                 {
2686                                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
2687                                         DE_NULL,
2688
2689                                         getAllMemoryWriteFlags(),
2690                                         getAllMemoryReadFlags(),
2691
2692                                         queueIndex,
2693                                         queueIndex,
2694
2695                                         attachmentResources[attachmentNdx]->getSecondaryBuffer(),
2696                                         0,
2697                                         attachmentResources[attachmentNdx]->getSecondaryBufferSize()
2698                                 };
2699
2700                                 bufferBarriers.push_back(secondaryBufferBarrier);
2701                         }
2702                 }
2703
2704                 if (!bufferBarriers.empty())
2705                         vk.cmdPipelineBarrier(commandBuffer,
2706                                                                   getAllPipelineStageFlags(),
2707                                                                   getAllPipelineStageFlags(),
2708                                                                   (VkDependencyFlags)0,
2709                                                                   0, (const VkMemoryBarrier*)DE_NULL,
2710                                                                   (deUint32)bufferBarriers.size(), &bufferBarriers[0],
2711                                                                   0, (const VkImageMemoryBarrier*)DE_NULL);
2712         }
2713 }
2714
2715 class PixelValue
2716 {
2717 public:
2718                                 PixelValue              (const Maybe<bool>&     x = nothing<bool>(),
2719                                                                  const Maybe<bool>&     y = nothing<bool>(),
2720                                                                  const Maybe<bool>&     z = nothing<bool>(),
2721                                                                  const Maybe<bool>&     w = nothing<bool>());
2722
2723         void            setUndefined    (size_t ndx);
2724         void            setValue                (size_t ndx, bool value);
2725         Maybe<bool>     getValue                (size_t ndx) const;
2726
2727 private:
2728         deUint16        m_status;
2729 };
2730
2731 PixelValue::PixelValue (const Maybe<bool>&      x,
2732                                                 const Maybe<bool>&      y,
2733                                                 const Maybe<bool>&      z,
2734                                                 const Maybe<bool>&      w)
2735         : m_status (0)
2736 {
2737         const Maybe<bool> values[] =
2738         {
2739                 x, y, z, w
2740         };
2741
2742         for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(values); ndx++)
2743         {
2744                 if (values[ndx])
2745                         setValue(ndx, *values[ndx]);
2746                 else
2747                         setUndefined(ndx);
2748         }
2749
2750         DE_ASSERT(m_status <= 0xFFu);
2751 }
2752
2753 void PixelValue::setUndefined (size_t ndx)
2754 {
2755         DE_ASSERT(ndx < 4);
2756         DE_ASSERT(m_status <= 0xFFu);
2757
2758         m_status &= (deUint16)~(0x1u << (deUint16)(ndx * 2));
2759         DE_ASSERT(m_status <= 0xFFu);
2760 }
2761
2762 void PixelValue::setValue (size_t ndx, bool value)
2763 {
2764         DE_ASSERT(ndx < 4);
2765         DE_ASSERT(m_status <= 0xFFu);
2766
2767         m_status = (deUint16)(m_status | (deUint16)(0x1u << (ndx * 2)));
2768
2769         if (value)
2770                 m_status = (deUint16)(m_status | (deUint16)(0x1u << (ndx * 2 + 1)));
2771         else
2772                 m_status &= (deUint16)~(0x1u << (deUint16)(ndx * 2 + 1));
2773
2774         DE_ASSERT(m_status <= 0xFFu);
2775 }
2776
2777 Maybe<bool> PixelValue::getValue (size_t ndx) const
2778 {
2779         DE_ASSERT(ndx < 4);
2780         DE_ASSERT(m_status <= 0xFFu);
2781
2782         if ((m_status & (0x1u << (deUint16)(ndx * 2))) != 0)
2783         {
2784                 return just((m_status & (0x1u << (deUint32)(ndx * 2 + 1))) != 0);
2785         }
2786         else
2787                 return nothing<bool>();
2788 }
2789
2790 void clearReferenceValues (vector<PixelValue>&  values,
2791                                                    const UVec2&                 targetSize,
2792                                                    const UVec2&                 offset,
2793                                                    const UVec2&                 size,
2794                                                    const BVec4&                 mask,
2795                                                    const PixelValue&    value)
2796 {
2797         DE_ASSERT(targetSize.x() * targetSize.y() == (deUint32)values.size());
2798         DE_ASSERT(offset.x() + size.x() <= targetSize.x());
2799         DE_ASSERT(offset.y() + size.y() <= targetSize.y());
2800
2801         for (deUint32 y = offset.y(); y < offset.y() + size.y(); y++)
2802         for (deUint32 x = offset.x(); x < offset.x() + size.x(); x++)
2803         {
2804                 for (int compNdx = 0; compNdx < 4; compNdx++)
2805                 {
2806                         if (mask[compNdx])
2807                         {
2808                                 if (value.getValue(compNdx))
2809                                         values[x + y * targetSize.x()].setValue(compNdx, *value.getValue(compNdx));
2810                                 else
2811                                         values[x + y * targetSize.x()].setUndefined(compNdx);
2812                         }
2813                 }
2814         }
2815 }
2816
2817 void markUndefined (vector<PixelValue>& values,
2818                                         const BVec4&            mask,
2819                                         const UVec2&            targetSize,
2820                                         const UVec2&            offset,
2821                                         const UVec2&            size)
2822 {
2823         DE_ASSERT(targetSize.x() * targetSize.y() == (deUint32)values.size());
2824
2825         for (deUint32 y = offset.y(); y < offset.y() + size.y(); y++)
2826         for (deUint32 x = offset.x(); x < offset.x() + size.x(); x++)
2827         {
2828                 for (int compNdx = 0; compNdx < 4; compNdx++)
2829                 {
2830                         if (mask[compNdx])
2831                                 values[x + y * targetSize.x()].setUndefined(compNdx);
2832                 }
2833         }
2834 }
2835
2836 PixelValue clearValueToPixelValue (const VkClearValue&                  value,
2837                                                                    const tcu::TextureFormat&    format)
2838 {
2839         const bool      isDepthAttachment                       = hasDepthComponent(format.order);
2840         const bool      isStencilAttachment                     = hasStencilComponent(format.order);
2841         const bool      isDepthOrStencilAttachment      = isDepthAttachment || isStencilAttachment;
2842         PixelValue      pixelValue;
2843
2844         if (isDepthOrStencilAttachment)
2845         {
2846                 if (isDepthAttachment)
2847                 {
2848                         if (value.depthStencil.depth == 1.0f)
2849                                 pixelValue.setValue(0, true);
2850                         else if (value.depthStencil.depth == 0.0f)
2851                                 pixelValue.setValue(0, false);
2852                         else
2853                                 DE_FATAL("Unknown depth value");
2854                 }
2855
2856                 if (isStencilAttachment)
2857                 {
2858                         if (value.depthStencil.stencil == 0xFFu)
2859                                 pixelValue.setValue(1, true);
2860                         else if (value.depthStencil.stencil == 0x0u)
2861                                 pixelValue.setValue(1, false);
2862                         else
2863                                 DE_FATAL("Unknown stencil value");
2864                 }
2865         }
2866         else
2867         {
2868                 const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(format.type);
2869                 const tcu::BVec4                                channelMask             = tcu::getTextureFormatChannelMask(format);
2870
2871                 switch (channelClass)
2872                 {
2873                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
2874                                 for (int i = 0; i < 4; i++)
2875                                 {
2876                                         if (channelMask[i])
2877                                         {
2878                                                 if (value.color.int32[i] == 1)
2879                                                         pixelValue.setValue(i, true);
2880                                                 else if (value.color.int32[i] == 0)
2881                                                         pixelValue.setValue(i, false);
2882                                                 else
2883                                                         DE_FATAL("Unknown clear color value");
2884                                         }
2885                                 }
2886                                 break;
2887
2888                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
2889                                 for (int i = 0; i < 4; i++)
2890                                 {
2891                                         if (channelMask[i])
2892                                         {
2893                                                 if (value.color.uint32[i] == 1u)
2894                                                         pixelValue.setValue(i, true);
2895                                                 else if (value.color.uint32[i] == 0u)
2896                                                         pixelValue.setValue(i, false);
2897                                                 else
2898                                                         DE_FATAL("Unknown clear color value");
2899                                         }
2900                                 }
2901                                 break;
2902
2903                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
2904                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
2905                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
2906                                 for (int i = 0; i < 4; i++)
2907                                 {
2908                                         if (channelMask[i])
2909                                         {
2910                                                 if (value.color.float32[i] == 1.0f)
2911                                                         pixelValue.setValue(i, true);
2912                                                 else if (value.color.float32[i] == 0.0f)
2913                                                         pixelValue.setValue(i, false);
2914                                                 else
2915                                                         DE_FATAL("Unknown clear color value");
2916                                         }
2917                                 }
2918                                 break;
2919
2920                         default:
2921                                 DE_FATAL("Unknown channel class");
2922                 }
2923         }
2924
2925         return pixelValue;
2926 }
2927
2928 void renderReferenceValues (vector<vector<PixelValue> >&                referenceAttachments,
2929                                                         const RenderPass&                                       renderPassInfo,
2930                                                         const UVec2&                                            targetSize,
2931                                                         const vector<Maybe<VkClearValue> >&     imageClearValues,
2932                                                         const vector<Maybe<VkClearValue> >&     renderPassClearValues,
2933                                                         const vector<SubpassRenderInfo>&        subpassRenderInfo,
2934                                                         const UVec2&                                            renderPos,
2935                                                         const UVec2&                                            renderSize)
2936 {
2937         const vector<Subpass>&  subpasses               = renderPassInfo.getSubpasses();
2938         vector<bool>                    attachmentUsed  (renderPassInfo.getAttachments().size(), false);
2939
2940         referenceAttachments.resize(renderPassInfo.getAttachments().size());
2941
2942         for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
2943         {
2944                 const Attachment                        attachment      = renderPassInfo.getAttachments()[attachmentNdx];
2945                 const tcu::TextureFormat        format          = mapVkFormat(attachment.getFormat());
2946                 vector<PixelValue>&                     reference       = referenceAttachments[attachmentNdx];
2947
2948                 reference.resize(targetSize.x() * targetSize.y());
2949
2950                 if (imageClearValues[attachmentNdx])
2951                         clearReferenceValues(reference, targetSize, UVec2(0, 0), targetSize, BVec4(true), clearValueToPixelValue(*imageClearValues[attachmentNdx], format));
2952         }
2953
2954         for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
2955         {
2956                 const Subpass&                                          subpass                         = subpasses[subpassNdx];
2957                 const SubpassRenderInfo&                        renderInfo                      = subpassRenderInfo[subpassNdx];
2958                 const vector<AttachmentReference>&      colorAttachments        = subpass.getColorAttachments();
2959
2960                 // Apply load op if attachment was used for the first time
2961                 for (size_t attachmentNdx = 0; attachmentNdx < colorAttachments.size(); attachmentNdx++)
2962                 {
2963                         const deUint32 attachmentIndex = colorAttachments[attachmentNdx].getAttachment();
2964
2965                         if (!attachmentUsed[attachmentIndex])
2966                         {
2967                                 const Attachment&                       attachment      = renderPassInfo.getAttachments()[attachmentIndex];
2968                                 vector<PixelValue>&                     reference       = referenceAttachments[attachmentIndex];
2969                                 const tcu::TextureFormat        format          = mapVkFormat(attachment.getFormat());
2970
2971                                 DE_ASSERT(!tcu::hasDepthComponent(format.order));
2972                                 DE_ASSERT(!tcu::hasStencilComponent(format.order));
2973
2974                                 if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
2975                                         clearReferenceValues(reference, targetSize, renderPos, renderSize, BVec4(true), clearValueToPixelValue(*renderPassClearValues[attachmentIndex], format));
2976                                 else if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
2977                                         markUndefined(reference, BVec4(true), targetSize, renderPos, renderSize);
2978
2979                                 attachmentUsed[attachmentIndex] = true;
2980                         }
2981                 }
2982
2983                 // Apply load op to depth/stencil attachment if it was used for the first time
2984                 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
2985                 {
2986                         const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
2987
2988                         // Apply load op if attachment was used for the first time
2989                         if (!attachmentUsed[attachmentIndex])
2990                         {
2991                                 const Attachment&                       attachment      = renderPassInfo.getAttachments()[attachmentIndex];
2992                                 vector<PixelValue>&                     reference       = referenceAttachments[attachmentIndex];
2993                                 const tcu::TextureFormat        format          = mapVkFormat(attachment.getFormat());
2994
2995                                 if (tcu::hasDepthComponent(format.order))
2996                                 {
2997                                         if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
2998                                                 clearReferenceValues(reference, targetSize, renderPos, renderSize, BVec4(true, false, false, false), clearValueToPixelValue(*renderPassClearValues[attachmentIndex], format));
2999                                         else if (attachment.getLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
3000                                                 markUndefined(reference, BVec4(true, false, false, false), targetSize, renderPos, renderSize);
3001                                 }
3002
3003                                 if (tcu::hasStencilComponent(format.order))
3004                                 {
3005                                         if (attachment.getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
3006                                                 clearReferenceValues(reference, targetSize, renderPos, renderSize, BVec4(false, true, false, false), clearValueToPixelValue(*renderPassClearValues[attachmentIndex], format));
3007                                         else if (attachment.getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_DONT_CARE)
3008                                                 markUndefined(reference, BVec4(false, true, false, false), targetSize, renderPos, renderSize);
3009                                 }
3010
3011                                 attachmentUsed[attachmentIndex] = true;
3012                         }
3013                 }
3014
3015                 for (size_t colorClearNdx = 0; colorClearNdx < renderInfo.getColorClears().size(); colorClearNdx++)
3016                 {
3017                         const ColorClear&                       colorClear              = renderInfo.getColorClears()[colorClearNdx];
3018                         const UVec2                                     offset                  = colorClear.getOffset();
3019                         const UVec2                                     size                    = colorClear.getSize();
3020                         const deUint32                          attachmentIndex = subpass.getColorAttachments()[colorClearNdx].getAttachment();
3021                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3022                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3023                         vector<PixelValue>&                     reference               = referenceAttachments[attachmentIndex];
3024                         VkClearValue                            value;
3025
3026                         value.color = colorClear.getColor();
3027
3028                         clearReferenceValues(reference, targetSize, offset, size, BVec4(true), clearValueToPixelValue(value, format));
3029                 }
3030
3031                 if (renderInfo.getDepthStencilClear())
3032                 {
3033                         const DepthStencilClear&        dsClear                 = *renderInfo.getDepthStencilClear();
3034                         const UVec2                                     offset                  = dsClear.getOffset();
3035                         const UVec2                                     size                    = dsClear.getSize();
3036                         const deUint32                          attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3037                         const VkImageLayout                     layout                  = subpass.getDepthStencilAttachment().getImageLayout();
3038                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3039                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3040                         const bool                                      hasStencil              = tcu::hasStencilComponent(format.order)
3041                                                                                                                 && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
3042                         const bool                                      hasDepth                = tcu::hasDepthComponent(format.order)
3043                                                                                                                 && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
3044                         vector<PixelValue>&                     reference               = referenceAttachments[attachmentIndex];
3045                         VkClearValue                            value;
3046
3047                         value.depthStencil.depth = dsClear.getDepth();
3048                         value.depthStencil.stencil = dsClear.getStencil();
3049
3050                         clearReferenceValues(reference, targetSize, offset, size, BVec4(hasDepth, hasStencil, false, false), clearValueToPixelValue(value, format));
3051                 }
3052
3053                 if (renderInfo.getRenderQuad())
3054                 {
3055                         const RenderQuad&       renderQuad      = *renderInfo.getRenderQuad();
3056                         const Vec2                      posA            = renderQuad.getCornerA();
3057                         const Vec2                      posB            = renderQuad.getCornerB();
3058                         const Vec2                      origin          = Vec2((float)renderInfo.getViewportOffset().x(), (float)renderInfo.getViewportOffset().y()) + Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
3059                         const Vec2                      p                       = Vec2((float)renderInfo.getViewportSize().x(), (float)renderInfo.getViewportSize().y()) / Vec2(2.0f);
3060                         const IVec2                     posAI           (deRoundFloatToInt32(origin.x() + (p.x() * posA.x())),
3061                                                                                          deRoundFloatToInt32(origin.y() + (p.y() * posA.y())));
3062                         const IVec2                     posBI           (deRoundFloatToInt32(origin.x() + (p.x() * posB.x())),
3063                                                                                          deRoundFloatToInt32(origin.y() + (p.y() * posB.y())));
3064
3065                         DE_ASSERT(posAI.x() < posBI.x());
3066                         DE_ASSERT(posAI.y() < posBI.y());
3067
3068                         if (subpass.getInputAttachments().empty())
3069                         {
3070                                 for (size_t attachmentRefNdx = 0; attachmentRefNdx < subpass.getColorAttachments().size(); attachmentRefNdx++)
3071                                 {
3072                                         const deUint32                          attachmentIndex = subpass.getColorAttachments()[attachmentRefNdx].getAttachment();
3073                                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3074                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3075                                         const tcu::BVec4                        channelMask             = tcu::getTextureFormatChannelMask(format);
3076                                         vector<PixelValue>&                     reference               = referenceAttachments[attachmentIndex];
3077
3078                                         for (int y = posAI.y(); y < (int)posBI.y(); y++)
3079                                         for (int x = posAI.x(); x < (int)posBI.x(); x++)
3080                                         {
3081                                                 for (int compNdx = 0; compNdx < 4; compNdx++)
3082                                                 {
3083                                                         const size_t    index   = subpassNdx + attachmentIndex + compNdx;
3084                                                         const BoolOp    op              = boolOpFromIndex(index);
3085                                                         const bool              boolX   = x % 2 == (int)(index % 2);
3086                                                         const bool              boolY   = y % 2 == (int)((index / 2) % 2);
3087
3088                                                         if (channelMask[compNdx])
3089                                                                 reference[x + y * targetSize.x()].setValue(compNdx, performBoolOp(op, boolX, boolY));
3090                                                 }
3091                                         }
3092                                 }
3093
3094                                 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
3095                                 {
3096                                         const deUint32                          attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3097                                         const VkImageLayout                     layout                  = subpass.getDepthStencilAttachment().getImageLayout();
3098                                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3099                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3100                                         vector<PixelValue>&                     reference               = referenceAttachments[attachmentIndex];
3101
3102                                         for (int y = posAI.y(); y < (int)posBI.y(); y++)
3103                                         for (int x = posAI.x(); x < (int)posBI.x(); x++)
3104                                         {
3105                                                 if (tcu::hasDepthComponent(format.order)
3106                                                         && layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3107                                                         && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3108                                                 {
3109                                                         const size_t    index   = subpassNdx + 1;
3110                                                         const BoolOp    op              = boolOpFromIndex(index);
3111                                                         const bool              boolX   = x % 2 == (int)(index % 2);
3112                                                         const bool              boolY   = y % 2 == (int)((index / 2) % 2);
3113
3114                                                         reference[x + y * targetSize.x()].setValue(0, performBoolOp(op, boolX, boolY));
3115                                                 }
3116
3117                                                 if (tcu::hasStencilComponent(format.order)
3118                                                         && layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3119                                                         && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3120                                                 {
3121                                                         const size_t    index   = subpassNdx;
3122                                                         reference[x + y * targetSize.x()].setValue(1, (index % 2) == 0);
3123                                                 }
3124                                         }
3125                                 }
3126                         }
3127                         else
3128                         {
3129                                 size_t                                  outputComponentCount    = 0;
3130                                 vector<Maybe<bool> >    inputs;
3131
3132                                 DE_ASSERT(posAI.x() < posBI.x());
3133                                 DE_ASSERT(posAI.y() < posBI.y());
3134
3135                                 for (size_t attachmentRefNdx = 0; attachmentRefNdx < subpass.getColorAttachments().size(); attachmentRefNdx++)
3136                                 {
3137                                         const deUint32                          attachmentIndex = subpass.getColorAttachments()[attachmentRefNdx].getAttachment();
3138                                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3139                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3140                                         const int                                       componentCount  = tcu::getNumUsedChannels(format.order);
3141
3142                                         outputComponentCount += (size_t)componentCount;
3143                                 }
3144
3145                                 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3146                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3147                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3148                                 {
3149                                         const Attachment&                       attachment      (renderPassInfo.getAttachments()[subpass.getDepthStencilAttachment().getAttachment()]);
3150                                         const tcu::TextureFormat        format          (mapVkFormat(attachment.getFormat()));
3151
3152                                         if (tcu::hasDepthComponent(format.order))
3153                                                 outputComponentCount++;
3154                                 }
3155
3156                                 if (outputComponentCount > 0)
3157                                 {
3158                                         for (int y = posAI.y(); y < (int)posBI.y(); y++)
3159                                         for (int x = posAI.x(); x < (int)posBI.x(); x++)
3160                                         {
3161                                                 for (size_t inputAttachmentNdx = 0; inputAttachmentNdx < subpass.getInputAttachments().size(); inputAttachmentNdx++)
3162                                                 {
3163                                                         const deUint32                          attachmentIndex = subpass.getInputAttachments()[inputAttachmentNdx].getAttachment();
3164                                                         const VkImageLayout                     layout                  = subpass.getInputAttachments()[inputAttachmentNdx].getImageLayout();
3165                                                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3166                                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3167                                                         const int                                       componentCount  = tcu::getNumUsedChannels(format.order);
3168
3169                                                         for (int compNdx = 0; compNdx < componentCount; compNdx++)
3170                                                         {
3171                                                                 if ((compNdx != 0 || layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3172                                                                         && (compNdx != 1 || layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL))
3173                                                                 {
3174                                                                         inputs.push_back(referenceAttachments[attachmentIndex][x + y * targetSize.x()].getValue(compNdx));
3175                                                                 }
3176                                                         }
3177                                                 }
3178
3179                                                 const size_t inputsPerOutput = inputs.size() >= outputComponentCount
3180                                                                                                                 ? ((inputs.size() / outputComponentCount)
3181                                                                                                                         + ((inputs.size() % outputComponentCount) != 0 ? 1 : 0))
3182                                                                                                                 : 1;
3183
3184                                                 size_t outputValueNdx = 0;
3185
3186                                                 for (size_t attachmentRefNdx = 0; attachmentRefNdx < subpass.getColorAttachments().size(); attachmentRefNdx++)
3187                                                 {
3188                                                         const deUint32                          attachmentIndex = subpass.getColorAttachments()[attachmentRefNdx].getAttachment();
3189                                                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3190                                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3191                                                         vector<PixelValue>&                     reference               = referenceAttachments[attachmentIndex];
3192                                                         const int                                       componentCount  = tcu::getNumUsedChannels(format.order);
3193
3194                                                         for (int compNdx = 0; compNdx < componentCount; compNdx++)
3195                                                         {
3196                                                                 const size_t    index   = subpassNdx + attachmentIndex + outputValueNdx;
3197                                                                 const BoolOp    op              = boolOpFromIndex(index);
3198                                                                 const bool              boolX   = x % 2 == (int)(index % 2);
3199                                                                 const bool              boolY   = y % 2 == (int)((index / 2) % 2);
3200                                                                 Maybe<bool>             output  = tcu::just(performBoolOp(op, boolX, boolY));
3201
3202                                                                 for (size_t i = 0; i < inputsPerOutput; i++)
3203                                                                 {
3204                                                                         if (!output)
3205                                                                                 break;
3206                                                                         else if (!inputs[((outputValueNdx + compNdx) * inputsPerOutput + i) % inputs.size()])
3207                                                                                 output = tcu::nothing<bool>();
3208                                                                         else
3209                                                                                 output = (*output) == (*inputs[((outputValueNdx + compNdx) * inputsPerOutput + i) % inputs.size()]);
3210                                                                 }
3211
3212                                                                 if (output)
3213                                                                         reference[x + y * targetSize.x()].setValue(compNdx, *output);
3214                                                                 else
3215                                                                         reference[x + y * targetSize.x()].setUndefined(compNdx);
3216                                                         }
3217
3218                                                         outputValueNdx += componentCount;
3219                                                 }
3220
3221                                                 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3222                                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3223                                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3224                                                 {
3225                                                         const deUint32          attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3226                                                         vector<PixelValue>&     reference               = referenceAttachments[attachmentIndex];
3227                                                         const size_t            index                   = subpassNdx + attachmentIndex;
3228                                                         const BoolOp            op                              = boolOpFromIndex(index);
3229                                                         const bool                      boolX                   = x % 2 == (int)(index % 2);
3230                                                         const bool                      boolY                   = y % 2 == (int)((index / 2) % 2);
3231                                                         Maybe<bool>                     output                  = tcu::just(performBoolOp(op, boolX, boolY));
3232
3233                                                         for (size_t i = 0; i < inputsPerOutput; i++)
3234                                                         {
3235                                                                 if (!output)
3236                                                                         break;
3237                                                                 else if (inputs[(outputValueNdx * inputsPerOutput + i) % inputs.size()])
3238                                                                         output = (*output) == (*inputs[(outputValueNdx * inputsPerOutput + i) % inputs.size()]);
3239                                                                 else
3240                                                                         output = tcu::nothing<bool>();
3241                                                         }
3242
3243                                                         if (output)
3244                                                                 reference[x + y * targetSize.x()].setValue(0, *output);
3245                                                         else
3246                                                                 reference[x + y * targetSize.x()].setUndefined(0);
3247                                                 }
3248
3249                                                 inputs.clear();
3250                                         }
3251                                 }
3252
3253                                 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3254                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3255                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3256                                 {
3257                                         const deUint32                          attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3258                                         const Attachment&                       attachment              = renderPassInfo.getAttachments()[attachmentIndex];
3259                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3260                                         vector<PixelValue>&                     reference               = referenceAttachments[attachmentIndex];
3261
3262                                         if (tcu::hasStencilComponent(format.order))
3263                                         {
3264                                                 for (int y = posAI.y(); y < (int)posBI.y(); y++)
3265                                                 for (int x = posAI.x(); x < (int)posBI.x(); x++)
3266                                                 {
3267                                                         const size_t    index   = subpassNdx;
3268                                                         reference[x + y * targetSize.x()].setValue(1, (index % 2) == 0);
3269                                                 }
3270                                         }
3271                                 }
3272                         }
3273                 }
3274         }
3275
3276         // Mark all attachments that were used but not stored as undefined
3277         for (size_t attachmentIndex = 0; attachmentIndex < renderPassInfo.getAttachments().size(); attachmentIndex++)
3278         {
3279                 const Attachment                        attachment                                      = renderPassInfo.getAttachments()[attachmentIndex];
3280                 const tcu::TextureFormat        format                                          = mapVkFormat(attachment.getFormat());
3281                 vector<PixelValue>&                     reference                                       = referenceAttachments[attachmentIndex];
3282                 const bool                                      isStencilAttachment                     = hasStencilComponent(format.order);
3283                 const bool                                      isDepthOrStencilAttachment      = hasDepthComponent(format.order) || isStencilAttachment;
3284
3285                 if (attachmentUsed[attachmentIndex] && renderPassInfo.getAttachments()[attachmentIndex].getStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
3286                 {
3287                         if (isDepthOrStencilAttachment)
3288                                 markUndefined(reference, BVec4(true, false, false, false), targetSize, renderPos, renderSize);
3289                         else
3290                                 markUndefined(reference, BVec4(true), targetSize, renderPos, renderSize);
3291                 }
3292
3293                 if (attachmentUsed[attachmentIndex] && isStencilAttachment && renderPassInfo.getAttachments()[attachmentIndex].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_DONT_CARE)
3294                         markUndefined(reference, BVec4(false, true, false, false), targetSize, renderPos, renderSize);
3295         }
3296 }
3297
3298 void renderReferenceImagesFromValues (vector<tcu::TextureLevel>&                        referenceImages,
3299                                                                           const vector<vector<PixelValue> >&    referenceValues,
3300                                                                           const UVec2&                                                  targetSize,
3301                                                                           const RenderPass&                                             renderPassInfo)
3302 {
3303         referenceImages.resize(referenceValues.size());
3304
3305         for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
3306         {
3307                 const Attachment                        attachment                      = renderPassInfo.getAttachments()[attachmentNdx];
3308                 const tcu::TextureFormat        format                          = mapVkFormat(attachment.getFormat());
3309                 const vector<PixelValue>&       reference                       = referenceValues[attachmentNdx];
3310                 const bool                                      hasDepth                        = tcu::hasDepthComponent(format.order);
3311                 const bool                                      hasStencil                      = tcu::hasStencilComponent(format.order);
3312                 const bool                                      hasDepthOrStencil       = hasDepth || hasStencil;
3313                 tcu::TextureLevel&                      referenceImage          = referenceImages[attachmentNdx];
3314
3315                 referenceImage.setStorage(format, targetSize.x(), targetSize.y());
3316
3317                 if (hasDepthOrStencil)
3318                 {
3319                         if (hasDepth)
3320                         {
3321                                 const PixelBufferAccess depthAccess (tcu::getEffectiveDepthStencilAccess(referenceImage.getAccess(), tcu::Sampler::MODE_DEPTH));
3322
3323                                 for (deUint32 y = 0; y < targetSize.y(); y++)
3324                                 for (deUint32 x = 0; x < targetSize.x(); x++)
3325                                 {
3326                                         if (reference[x + y * targetSize.x()].getValue(0))
3327                                         {
3328                                                 if (*reference[x + y * targetSize.x()].getValue(0))
3329                                                         depthAccess.setPixDepth(1.0f, x, y);
3330                                                 else
3331                                                         depthAccess.setPixDepth(0.0f, x, y);
3332                                         }
3333                                         else // Fill with 3x3 grid
3334                                                 depthAccess.setPixDepth(((x / 3) % 2) == ((y / 3) % 2) ? 0.33f : 0.66f, x, y);
3335                                 }
3336                         }
3337
3338                         if (hasStencil)
3339                         {
3340                                 const PixelBufferAccess stencilAccess (tcu::getEffectiveDepthStencilAccess(referenceImage.getAccess(), tcu::Sampler::MODE_STENCIL));
3341
3342                                 for (deUint32 y = 0; y < targetSize.y(); y++)
3343                                 for (deUint32 x = 0; x < targetSize.x(); x++)
3344                                 {
3345                                         if (reference[x + y * targetSize.x()].getValue(1))
3346                                         {
3347                                                 if (*reference[x + y * targetSize.x()].getValue(1))
3348                                                         stencilAccess.setPixStencil(0xFFu, x, y);
3349                                                 else
3350                                                         stencilAccess.setPixStencil(0x0u, x, y);
3351                                         }
3352                                         else // Fill with 3x3 grid
3353                                                 stencilAccess.setPixStencil(((x / 3) % 2) == ((y / 3) % 2) ? 85 : 170, x, y);
3354                                 }
3355                         }
3356                 }
3357                 else
3358                 {
3359                         for (deUint32 y = 0; y < targetSize.y(); y++)
3360                         for (deUint32 x = 0; x < targetSize.x(); x++)
3361                         {
3362                                 tcu::Vec4 color;
3363
3364                                 for (int compNdx = 0; compNdx < 4; compNdx++)
3365                                 {
3366                                         if (reference[x + y * targetSize.x()].getValue(compNdx))
3367                                         {
3368                                                 if (*reference[x + y * targetSize.x()].getValue(compNdx))
3369                                                         color[compNdx] = 1.0f;
3370                                                 else
3371                                                         color[compNdx] = 0.0f;
3372                                         }
3373                                         else // Fill with 3x3 grid
3374                                                 color[compNdx] = ((compNdx + (x / 3)) % 2) == ((y / 3) % 2) ? 0.33f : 0.66f;
3375                                 }
3376
3377                                 referenceImage.getAccess().setPixel(color, x, y);
3378                         }
3379                 }
3380         }
3381 }
3382
3383 bool verifyColorAttachment (const vector<PixelValue>&           reference,
3384                                                         const ConstPixelBufferAccess&   result,
3385                                                         const PixelBufferAccess&                errorImage)
3386 {
3387         const Vec4      red             (1.0f, 0.0f, 0.0f, 1.0f);
3388         const Vec4      green   (0.0f, 1.0f, 0.0f, 1.0f);
3389         bool            ok              = true;
3390
3391         DE_ASSERT(result.getWidth() * result.getHeight() == (int)reference.size());
3392         DE_ASSERT(result.getWidth() == errorImage.getWidth());
3393         DE_ASSERT(result.getHeight() == errorImage.getHeight());
3394
3395         for (int y = 0; y < result.getHeight(); y++)
3396         for (int x = 0; x < result.getWidth(); x++)
3397         {
3398                 const Vec4                      resultColor             = result.getPixel(x, y);
3399                 const PixelValue&       referenceValue  = reference[x + y * result.getWidth()];
3400                 bool                            pixelOk                 = true;
3401
3402                 for (int compNdx = 0; compNdx < 4; compNdx++)
3403                 {
3404                         const Maybe<bool> maybeValue = referenceValue.getValue(compNdx);
3405
3406                         if (maybeValue)
3407                         {
3408                                 const bool value = *maybeValue;
3409
3410                                 if ((value && (resultColor[compNdx] != 1.0f))
3411                                         || (!value && resultColor[compNdx] != 0.0f))
3412                                         pixelOk = false;
3413                         }
3414                 }
3415
3416                 if (!pixelOk)
3417                 {
3418                         errorImage.setPixel(red, x, y);
3419                         ok = false;
3420                 }
3421                 else
3422                         errorImage.setPixel(green, x, y);
3423         }
3424
3425         return ok;
3426 }
3427
3428 bool verifyDepthAttachment (const vector<PixelValue>&           reference,
3429                                                         const ConstPixelBufferAccess&   result,
3430                                                         const PixelBufferAccess&                errorImage)
3431 {
3432         const Vec4      red             (1.0f, 0.0f, 0.0f, 1.0f);
3433         const Vec4      green   (0.0f, 1.0f, 0.0f, 1.0f);
3434         bool            ok              = true;
3435
3436         DE_ASSERT(result.getWidth() * result.getHeight() == (int)reference.size());
3437         DE_ASSERT(result.getWidth() == errorImage.getWidth());
3438         DE_ASSERT(result.getHeight() == errorImage.getHeight());
3439
3440         for (int y = 0; y < result.getHeight(); y++)
3441         for (int x = 0; x < result.getWidth(); x++)
3442         {
3443                 bool pixelOk = true;
3444
3445                 const float                     resultDepth             = result.getPixDepth(x, y);
3446                 const PixelValue&       referenceValue  = reference[x + y * result.getWidth()];
3447                 const Maybe<bool>       maybeValue              = referenceValue.getValue(0);
3448
3449                 if (maybeValue)
3450                 {
3451                         const bool value = *maybeValue;
3452
3453                         if ((value && (resultDepth != 1.0f))
3454                                 || (!value && resultDepth != 0.0f))
3455                                 pixelOk = false;
3456                 }
3457
3458                 if (!pixelOk)
3459                 {
3460                         errorImage.setPixel(red, x, y);
3461                         ok = false;
3462                 }
3463                 else
3464                         errorImage.setPixel(green, x, y);
3465         }
3466
3467         return ok;
3468 }
3469
3470 bool verifyStencilAttachment (const vector<PixelValue>&         reference,
3471                                                           const ConstPixelBufferAccess& result,
3472                                                           const PixelBufferAccess&              errorImage)
3473 {
3474         const Vec4      red             (1.0f, 0.0f, 0.0f, 1.0f);
3475         const Vec4      green   (0.0f, 1.0f, 0.0f, 1.0f);
3476         bool            ok              = true;
3477
3478         DE_ASSERT(result.getWidth() * result.getHeight() == (int)reference.size());
3479         DE_ASSERT(result.getWidth() == errorImage.getWidth());
3480         DE_ASSERT(result.getHeight() == errorImage.getHeight());
3481
3482         for (int y = 0; y < result.getHeight(); y++)
3483         for (int x = 0; x < result.getWidth(); x++)
3484         {
3485                 bool pixelOk = true;
3486
3487                 const deUint32          resultStencil   = result.getPixStencil(x, y);
3488                 const PixelValue&       referenceValue  = reference[x + y * result.getWidth()];
3489                 const Maybe<bool>       maybeValue              = referenceValue.getValue(1);
3490
3491                 if (maybeValue)
3492                 {
3493                         const bool value = *maybeValue;
3494
3495                         if ((value && (resultStencil != 0xFFu))
3496                                 || (!value && resultStencil != 0x0u))
3497                                 pixelOk = false;
3498                 }
3499
3500                 if (!pixelOk)
3501                 {
3502                         errorImage.setPixel(red, x, y);
3503                         ok = false;
3504                 }
3505                 else
3506                         errorImage.setPixel(green, x, y);
3507         }
3508
3509         return ok;
3510 }
3511
3512 bool logAndVerifyImages (TestLog&                                                                                       log,
3513                                                  const DeviceInterface&                                                         vk,
3514                                                  VkDevice                                                                                       device,
3515                                                  const vector<de::SharedPtr<AttachmentResources> >&     attachmentResources,
3516                                                  const vector<bool>&                                                            attachmentIsLazy,
3517                                                  const RenderPass&                                                                      renderPassInfo,
3518                                                  const vector<Maybe<VkClearValue> >&                            renderPassClearValues,
3519                                                  const vector<Maybe<VkClearValue> >&                            imageClearValues,
3520                                                  const vector<SubpassRenderInfo>&                                       subpassRenderInfo,
3521                                                  const UVec2&                                                                           targetSize,
3522                                                  const TestConfig&                                                                      config)
3523 {
3524         vector<vector<PixelValue> >     referenceValues;
3525         vector<tcu::TextureLevel>       referenceAttachments;
3526         bool                                            isOk                                    = true;
3527
3528         log << TestLog::Message << "Reference images fill undefined pixels with 3x3 grid pattern." << TestLog::EndMessage;
3529
3530         renderReferenceValues(referenceValues, renderPassInfo, targetSize, imageClearValues, renderPassClearValues, subpassRenderInfo, config.renderPos, config.renderSize);
3531         renderReferenceImagesFromValues(referenceAttachments, referenceValues, targetSize, renderPassInfo);
3532
3533         for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
3534         {
3535                 if (!attachmentIsLazy[attachmentNdx])
3536                 {
3537                         const Attachment                        attachment              = renderPassInfo.getAttachments()[attachmentNdx];
3538                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3539
3540                         if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
3541                         {
3542                                 const tcu::TextureFormat        depthFormat                     = getDepthCopyFormat(attachment.getFormat());
3543                                 const VkDeviceSize                      depthBufferSize         = targetSize.x() * targetSize.y() * depthFormat.getPixelSize();
3544                                 void* const                                     depthPtr                        = attachmentResources[attachmentNdx]->getResultMemory().getHostPtr();
3545
3546                                 const tcu::TextureFormat        stencilFormat           = getStencilCopyFormat(attachment.getFormat());
3547                                 const VkDeviceSize                      stencilBufferSize       = targetSize.x() * targetSize.y() * stencilFormat.getPixelSize();
3548                                 void* const                                     stencilPtr                      = attachmentResources[attachmentNdx]->getSecondaryResultMemory().getHostPtr();
3549
3550                                 const VkMappedMemoryRange       ranges[]                        =
3551                                 {
3552                                         {
3553                                                 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,                                                          // sType;
3554                                                 DE_NULL,                                                                                                                        // pNext;
3555                                                 attachmentResources[attachmentNdx]->getResultMemory().getMemory(),      // mem;
3556                                                 attachmentResources[attachmentNdx]->getResultMemory().getOffset(),      // offset;
3557                                                 depthBufferSize                                                                                                         // size;
3558                                         },
3559                                         {
3560                                                 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,                                                                          // sType;
3561                                                 DE_NULL,                                                                                                                                        // pNext;
3562                                                 attachmentResources[attachmentNdx]->getSecondaryResultMemory().getMemory(),     // mem;
3563                                                 attachmentResources[attachmentNdx]->getSecondaryResultMemory().getOffset(),     // offset;
3564                                                 stencilBufferSize                                                                                                                       // size;
3565                                         }
3566                                 };
3567                                 VK_CHECK(vk.invalidateMappedMemoryRanges(device, 2u, ranges));
3568
3569                                 {
3570                                         const ConstPixelBufferAccess    depthAccess                     (depthFormat, targetSize.x(), targetSize.y(), 1, depthPtr);
3571                                         const ConstPixelBufferAccess    stencilAccess           (stencilFormat, targetSize.x(), targetSize.y(), 1, stencilPtr);
3572                                         tcu::TextureLevel                               depthErrorImage         (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
3573                                         tcu::TextureLevel                               stencilErrorImage       (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
3574
3575                                         log << TestLog::Image("Attachment" + de::toString(attachmentNdx) + "Depth", "Attachment " + de::toString(attachmentNdx) + " Depth", depthAccess);
3576                                         log << TestLog::Image("Attachment" + de::toString(attachmentNdx) + "Stencil", "Attachment " + de::toString(attachmentNdx) + " Stencil", stencilAccess);
3577
3578                                         log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceAttachments[attachmentNdx].getAccess());
3579
3580                                         if (renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE
3581                                                 && !verifyDepthAttachment(referenceValues[attachmentNdx], depthAccess, depthErrorImage.getAccess()))
3582                                         {
3583                                                 log << TestLog::Image("DepthAttachmentError" + de::toString(attachmentNdx), "Depth Attachment Error " + de::toString(attachmentNdx), depthErrorImage.getAccess());
3584                                                 isOk = false;
3585                                         }
3586
3587                                         if (renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE
3588                                                 && !verifyStencilAttachment(referenceValues[attachmentNdx], stencilAccess, stencilErrorImage.getAccess()))
3589                                         {
3590                                                 log << TestLog::Image("StencilAttachmentError" + de::toString(attachmentNdx), "Stencil Attachment Error " + de::toString(attachmentNdx), stencilErrorImage.getAccess());
3591                                                 isOk = false;
3592                                         }
3593                                 }
3594                         }
3595                         else
3596                         {
3597                                 const VkDeviceSize                      bufferSize      = targetSize.x() * targetSize.y() * format.getPixelSize();
3598                                 void* const                                     ptr                     = attachmentResources[attachmentNdx]->getResultMemory().getHostPtr();
3599
3600                                 const VkMappedMemoryRange       range           =
3601                                 {
3602                                         VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,                                                          // sType;
3603                                         DE_NULL,                                                                                                                        // pNext;
3604                                         attachmentResources[attachmentNdx]->getResultMemory().getMemory(),      // mem;
3605                                         attachmentResources[attachmentNdx]->getResultMemory().getOffset(),      // offset;
3606                                         bufferSize                                                                                                                      // size;
3607                                 };
3608                                 VK_CHECK(vk.invalidateMappedMemoryRanges(device, 1u, &range));
3609
3610                                 if (tcu::hasDepthComponent(format.order))
3611                                 {
3612                                         const ConstPixelBufferAccess    access          (format, targetSize.x(), targetSize.y(), 1, ptr);
3613                                         tcu::TextureLevel                               errorImage      (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
3614
3615                                         log << TestLog::Image("Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx), access);
3616                                         log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceAttachments[attachmentNdx].getAccess());
3617
3618                                         if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
3619                                                 && !verifyDepthAttachment(referenceValues[attachmentNdx], access, errorImage.getAccess()))
3620                                         {
3621                                                 log << TestLog::Image("AttachmentError" + de::toString(attachmentNdx), "Attachment Error " + de::toString(attachmentNdx), errorImage.getAccess());
3622                                                 isOk = false;
3623                                         }
3624                                 }
3625                                 else if (tcu::hasStencilComponent(format.order))
3626                                 {
3627                                         const ConstPixelBufferAccess    access          (format, targetSize.x(), targetSize.y(), 1, ptr);
3628                                         tcu::TextureLevel                               errorImage      (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
3629
3630                                         log << TestLog::Image("Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx), access);
3631                                         log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceAttachments[attachmentNdx].getAccess());
3632
3633                                         if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
3634                                                 && !verifyStencilAttachment(referenceValues[attachmentNdx], access, errorImage.getAccess()))
3635                                         {
3636                                                 log << TestLog::Image("AttachmentError" + de::toString(attachmentNdx), "Attachment Error " + de::toString(attachmentNdx), errorImage.getAccess());
3637                                                 isOk = false;
3638                                         }
3639                                 }
3640                                 else
3641                                 {
3642                                         const ConstPixelBufferAccess    access          (format, targetSize.x(), targetSize.y(), 1, ptr);
3643                                         tcu::TextureLevel                               errorImage      (tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), targetSize.x(), targetSize.y());
3644
3645                                         log << TestLog::Image("Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx), access);
3646                                         log << TestLog::Image("AttachmentReference" + de::toString(attachmentNdx), "Attachment reference " + de::toString(attachmentNdx), referenceAttachments[attachmentNdx].getAccess());
3647
3648                                         if ((renderPassInfo.getAttachments()[attachmentNdx].getStoreOp() == VK_ATTACHMENT_STORE_OP_STORE || renderPassInfo.getAttachments()[attachmentNdx].getStencilStoreOp() == VK_ATTACHMENT_STORE_OP_STORE)
3649                                                 && !verifyColorAttachment(referenceValues[attachmentNdx], access, errorImage.getAccess()))
3650                                         {
3651                                                 log << TestLog::Image("AttachmentError" + de::toString(attachmentNdx), "Attachment Error " + de::toString(attachmentNdx), errorImage.getAccess());
3652                                                 isOk = false;
3653                                         }
3654                                 }
3655                         }
3656                 }
3657         }
3658
3659         return isOk;
3660 }
3661
3662 std::string getInputAttachmentType (VkFormat vkFormat)
3663 {
3664         const tcu::TextureFormat                format                  = mapVkFormat(vkFormat);
3665         const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(format.type);
3666
3667         switch (channelClass)
3668         {
3669                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
3670                         return "isubpassInput";
3671
3672                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
3673                         return "usubpassInput";
3674
3675                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
3676                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
3677                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
3678                         return "subpassInput";
3679
3680                 default:
3681                         DE_FATAL("Unknown channel class");
3682                         return "";
3683         }
3684 }
3685
3686 std::string getAttachmentType (VkFormat vkFormat)
3687 {
3688         const tcu::TextureFormat                format                  = mapVkFormat(vkFormat);
3689         const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(format.type);
3690
3691         switch (channelClass)
3692         {
3693                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
3694                         return "ivec4";
3695
3696                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
3697                         return "uvec4";
3698
3699                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
3700                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
3701                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
3702                         return "vec4";
3703
3704                 default:
3705                         DE_FATAL("Unknown channel class");
3706                         return "";
3707         }
3708 }
3709
3710 void createTestShaders (SourceCollections& dst, TestConfig config)
3711 {
3712         if (config.renderTypes & TestConfig::RENDERTYPES_DRAW)
3713         {
3714                 const vector<Subpass>&  subpasses       = config.renderPass.getSubpasses();
3715
3716                 for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
3717                 {
3718                         const Subpass&          subpass                                 = subpasses[subpassNdx];
3719                         deUint32                        inputAttachmentBinding  = 0;
3720                         std::ostringstream      vertexShader;
3721                         std::ostringstream      fragmentShader;
3722
3723                         vertexShader << "#version 310 es\n"
3724                                                  << "layout(location = 0) in highp vec2 a_position;\n"
3725                                                  << "void main (void) {\n"
3726                                                  << "\tgl_Position = vec4(a_position, 1.0, 1.0);\n"
3727                                                  << "}\n";
3728
3729                         fragmentShader << "#version 310 es\n"
3730                                                    << "precision highp float;\n";
3731
3732                         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
3733                         {
3734                                 const deUint32                          attachmentIndex = subpass.getInputAttachments()[attachmentNdx].getAttachment();
3735                                 const VkImageLayout                     layout                  = subpass.getInputAttachments()[attachmentNdx].getImageLayout();
3736                                 const Attachment                        attachment              = config.renderPass.getAttachments()[attachmentIndex];
3737                                 const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3738                                 const bool                                      isDepthFormat   = tcu::hasDepthComponent(format.order);
3739                                 const bool                                      isStencilFormat = tcu::hasStencilComponent(format.order);
3740
3741                                 if (isDepthFormat || isStencilFormat)
3742                                 {
3743                                         if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3744                                         {
3745                                                 fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp subpassInput i_depth" << attachmentNdx << ";\n";
3746                                                 inputAttachmentBinding++;
3747                                         }
3748
3749                                         if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3750                                         {
3751                                                 fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp usubpassInput i_stencil" << attachmentNdx << ";\n";
3752                                                 inputAttachmentBinding++;
3753                                         }
3754                                 }
3755                                 else
3756                                 {
3757                                         const std::string attachmentType = getInputAttachmentType(attachment.getFormat());
3758
3759                                         fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp " << attachmentType << " i_color" << attachmentNdx << ";\n";
3760                                         inputAttachmentBinding++;
3761                                 }
3762                         }
3763
3764                         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
3765                         {
3766                                 const std::string attachmentType = getAttachmentType(config.renderPass.getAttachments()[subpass.getColorAttachments()[attachmentNdx].getAttachment()].getFormat());
3767                                 fragmentShader << "layout(location = " << attachmentNdx << ") out highp " << attachmentType << " o_color" << attachmentNdx << ";\n";
3768                         }
3769
3770                         fragmentShader << "void main (void) {\n";
3771
3772                         if (subpass.getInputAttachments().empty())
3773                         {
3774                                 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
3775                                 {
3776                                         const deUint32          attachmentIndex = subpass.getColorAttachments()[attachmentNdx].getAttachment();
3777                                         const std::string       attachmentType  = getAttachmentType(config.renderPass.getAttachments()[attachmentIndex].getFormat());
3778
3779                                         fragmentShader << "\to_color" << attachmentNdx << " = " << attachmentType << "(vec4(";
3780
3781                                         for (size_t compNdx = 0; compNdx < 4; compNdx++)
3782                                         {
3783                                                 const size_t    index   = subpassNdx + attachmentIndex + compNdx;
3784                                                 const BoolOp    op              = boolOpFromIndex(index);
3785
3786                                                 if (compNdx > 0)
3787                                                         fragmentShader << ",\n\t\t";
3788
3789                                                 fragmentShader  << "((int(gl_FragCoord.x) % 2 == " << (index % 2)
3790                                                                                 << ") " << boolOpToString(op) << " ("
3791                                                                                 << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
3792                                                                                 << ") ? 1.0 : 0.0)";
3793                                         }
3794
3795                                         fragmentShader << "));\n";
3796                                 }
3797
3798                                 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3799                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3800                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3801                                 {
3802                                         const size_t    index   = subpassNdx + 1;
3803                                         const BoolOp    op              = boolOpFromIndex(index);
3804
3805                                         fragmentShader  << "\tgl_FragDepth = ((int(gl_FragCoord.x) % 2 == " << (index % 2)
3806                                                                         << ") " << boolOpToString(op) << " ("
3807                                                                         << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
3808                                                                         << ") ? 1.0 : 0.0);\n";
3809                                 }
3810                         }
3811                         else
3812                         {
3813                                 size_t  inputComponentCount             = 0;
3814                                 size_t  outputComponentCount    = 0;
3815
3816                                 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
3817                                 {
3818                                         const deUint32                          attachmentIndex = subpass.getInputAttachments()[attachmentNdx].getAttachment();
3819                                         const VkImageLayout                     layout                  = subpass.getInputAttachments()[attachmentNdx].getImageLayout();
3820                                         const Attachment                        attachment              = config.renderPass.getAttachments()[attachmentIndex];
3821                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3822                                         const size_t                            componentCount  = (size_t)tcu::getNumUsedChannels(format.order);
3823
3824                                         if (layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3825                                                 inputComponentCount += 1;
3826                                         else if (layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3827                                                 inputComponentCount += 1;
3828                                         else
3829                                                 inputComponentCount += componentCount;
3830                                 }
3831
3832                                 for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
3833                                 {
3834                                         const deUint32                          attachmentIndex = subpass.getColorAttachments()[attachmentNdx].getAttachment();
3835                                         const Attachment                        attachment              = config.renderPass.getAttachments()[attachmentIndex];
3836                                         const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3837                                         const size_t                            componentCount  = (size_t)tcu::getNumUsedChannels(format.order);
3838
3839                                         outputComponentCount += componentCount;
3840                                 }
3841
3842                                 if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3843                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3844                                         && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3845                                 {
3846                                         outputComponentCount++;
3847                                 }
3848
3849                                 if (outputComponentCount > 0)
3850                                 {
3851                                         const size_t inputsPerOutput = inputComponentCount >= outputComponentCount
3852                                                                                                         ? ((inputComponentCount / outputComponentCount)
3853                                                                                                                 + ((inputComponentCount % outputComponentCount) != 0 ? 1 : 0))
3854                                                                                                         : 1;
3855
3856                                         fragmentShader << "\tbool inputs[" << inputComponentCount << "];\n";
3857
3858                                         if (outputComponentCount > 0)
3859                                                 fragmentShader << "\tbool outputs[" << outputComponentCount << "];\n";
3860
3861                                         size_t inputValueNdx = 0;
3862
3863                                         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
3864                                         {
3865                                                 const char* const       components[]    =
3866                                                 {
3867                                                         "x", "y", "z", "w"
3868                                                 };
3869                                                 const deUint32                          attachmentIndex = subpass.getInputAttachments()[attachmentNdx].getAttachment();
3870                                                 const VkImageLayout                     layout                  = subpass.getInputAttachments()[attachmentNdx].getImageLayout();
3871                                                 const Attachment                        attachment              = config.renderPass.getAttachments()[attachmentIndex];
3872                                                 const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3873                                                 const size_t                            componentCount  = (size_t)tcu::getNumUsedChannels(format.order);
3874                                                 const bool                                      isDepthFormat   = tcu::hasDepthComponent(format.order);
3875                                                 const bool                                      isStencilFormat = tcu::hasStencilComponent(format.order);
3876
3877                                                 if (isDepthFormat || isStencilFormat)
3878                                                 {
3879                                                         if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
3880                                                         {
3881                                                                 fragmentShader << "\tinputs[" << inputValueNdx << "] = 1.0 == float(subpassLoad(i_depth" << attachmentNdx << ").x);\n";
3882                                                                 inputValueNdx++;
3883                                                         }
3884
3885                                                         if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3886                                                         {
3887                                                                 fragmentShader << "\tinputs[" << inputValueNdx << "] = 255u == subpassLoad(i_stencil" << attachmentNdx << ").x;\n";
3888                                                                 inputValueNdx++;
3889                                                         }
3890                                                 }
3891                                                 else
3892                                                 {
3893                                                         for (size_t compNdx = 0; compNdx < componentCount; compNdx++)
3894                                                         {
3895                                                                 fragmentShader << "\tinputs[" << inputValueNdx << "] = 1.0 == float(subpassLoad(i_color" << attachmentNdx << ")." << components[compNdx] << ");\n";
3896                                                                 inputValueNdx++;
3897                                                         }
3898                                                 }
3899                                         }
3900
3901                                         size_t outputValueNdx = 0;
3902
3903                                         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
3904                                         {
3905                                                 const deUint32                          attachmentIndex = subpass.getColorAttachments()[attachmentNdx].getAttachment();
3906                                                 const Attachment                        attachment              = config.renderPass.getAttachments()[attachmentIndex];
3907                                                 const std::string                       attachmentType  = getAttachmentType(config.renderPass.getAttachments()[attachmentIndex].getFormat());
3908                                                 const tcu::TextureFormat        format                  = mapVkFormat(attachment.getFormat());
3909                                                 const size_t                            componentCount  = (size_t)tcu::getNumUsedChannels(format.order);
3910
3911                                                 for (size_t compNdx = 0; compNdx < componentCount; compNdx++)
3912                                                 {
3913                                                         const size_t    index   = subpassNdx + attachmentIndex + outputValueNdx;
3914                                                         const BoolOp    op              = boolOpFromIndex(index);
3915
3916                                                         fragmentShader << "\toutputs[" << outputValueNdx + compNdx << "] = "
3917                                                                                         << "(int(gl_FragCoord.x) % 2 == " << (index % 2)
3918                                                                                         << ") " << boolOpToString(op) << " ("
3919                                                                                         << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
3920                                                                                         << ");\n";
3921
3922                                                         for (size_t i = 0; i < inputsPerOutput; i++)
3923                                                                 fragmentShader << "\toutputs[" << outputValueNdx + compNdx << "] = outputs[" << outputValueNdx + compNdx << "] == inputs[" <<  ((outputValueNdx + compNdx) * inputsPerOutput + i) %  inputComponentCount << "];\n";
3924                                                 }
3925
3926                                                 fragmentShader << "\to_color" << attachmentNdx << " = " << attachmentType << "(";
3927
3928                                                 for (size_t compNdx = 0; compNdx < 4; compNdx++)
3929                                                 {
3930                                                         if (compNdx > 0)
3931                                                                 fragmentShader << ", ";
3932
3933                                                         if (compNdx < componentCount)
3934                                                                 fragmentShader << "outputs[" << outputValueNdx + compNdx << "]";
3935                                                         else
3936                                                                 fragmentShader << "0";
3937                                                 }
3938
3939                                                 outputValueNdx += componentCount;
3940
3941                                                 fragmentShader << ");\n";
3942                                         }
3943
3944                                         if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
3945                                                 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
3946                                                 && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
3947                                         {
3948                                                 const deUint32  attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
3949                                                 const size_t    index                   = subpassNdx + attachmentIndex;
3950                                                 const BoolOp    op                              = boolOpFromIndex(index);
3951
3952                                                 fragmentShader << "\toutputs[" << outputValueNdx << "] = "
3953                                                                                 << "(int(gl_FragCoord.x) % 2 == " << (index % 2)
3954                                                                                 << ") " << boolOpToString(op) << " ("
3955                                                                                 << "int(gl_FragCoord.y) % 2 == " << ((index / 2) % 2)
3956                                                                                 << ");\n";
3957
3958                                                 for (size_t i = 0; i < inputsPerOutput; i++)
3959                                                         fragmentShader << "\toutputs[" << outputValueNdx << "] = outputs[" << outputValueNdx << "] == inputs[" <<  (outputValueNdx * inputsPerOutput + i) %  inputComponentCount << "];\n";
3960
3961                                                 fragmentShader << "\tgl_FragDepth = outputs[" << outputValueNdx << "] ? 1.0 : 0.0;";
3962                                         }
3963                                 }
3964                         }
3965
3966                         fragmentShader << "}\n";
3967
3968                         dst.glslSources.add(de::toString(subpassNdx) + "-vert") << glu::VertexSource(vertexShader.str());
3969                         dst.glslSources.add(de::toString(subpassNdx) + "-frag") << glu::FragmentSource(fragmentShader.str());
3970                 }
3971         }
3972 }
3973
3974 void initializeAttachmentIsLazy (vector<bool>& attachmentIsLazy, const vector<Attachment>& attachments, TestConfig::ImageMemory imageMemory)
3975 {
3976         bool lastAttachmentWasLazy      = false;
3977
3978         for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
3979         {
3980                 if (attachments[attachmentNdx].getLoadOp() != VK_ATTACHMENT_LOAD_OP_LOAD
3981                         && attachments[attachmentNdx].getStoreOp() != VK_ATTACHMENT_STORE_OP_STORE
3982                         && attachments[attachmentNdx].getStencilLoadOp() != VK_ATTACHMENT_LOAD_OP_LOAD
3983                         && attachments[attachmentNdx].getStencilStoreOp() != VK_ATTACHMENT_STORE_OP_STORE)
3984                 {
3985                         if (imageMemory == TestConfig::IMAGEMEMORY_LAZY || (imageMemory & TestConfig::IMAGEMEMORY_LAZY && !lastAttachmentWasLazy))
3986                         {
3987                                 attachmentIsLazy.push_back(true);
3988
3989                                 lastAttachmentWasLazy   = true;
3990                         }
3991                         else if (imageMemory & TestConfig::IMAGEMEMORY_STRICT)
3992                         {
3993                                 attachmentIsLazy.push_back(false);
3994                                 lastAttachmentWasLazy = false;
3995                         }
3996                         else
3997                                 DE_FATAL("Unknown imageMemory");
3998                 }
3999                 else
4000                         attachmentIsLazy.push_back(false);
4001         }
4002 }
4003
4004 enum AttachmentRefType
4005 {
4006         ATTACHMENTREFTYPE_COLOR,
4007         ATTACHMENTREFTYPE_DEPTH_STENCIL,
4008         ATTACHMENTREFTYPE_INPUT,
4009         ATTACHMENTREFTYPE_RESOLVE,
4010 };
4011
4012 VkImageUsageFlags getImageUsageFromLayout (VkImageLayout layout)
4013 {
4014         switch (layout)
4015         {
4016                 case VK_IMAGE_LAYOUT_GENERAL:
4017                 case VK_IMAGE_LAYOUT_PREINITIALIZED:
4018                         return 0;
4019
4020                 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
4021                         return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4022
4023                 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
4024                 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
4025                         return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
4026
4027                 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
4028                         return VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
4029
4030                 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
4031                         return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
4032
4033                 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
4034                         return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
4035
4036                 default:
4037                         DE_FATAL("Unexpected image layout");
4038                         return 0;
4039         }
4040 }
4041
4042 void getImageUsageFromAttachmentReferences(vector<VkImageUsageFlags>& attachmentImageUsage, AttachmentRefType refType, size_t count, const AttachmentReference* references)
4043 {
4044         for (size_t referenceNdx = 0; referenceNdx < count; ++referenceNdx)
4045         {
4046                 const deUint32 attachment = references[referenceNdx].getAttachment();
4047
4048                 if (attachment != VK_ATTACHMENT_UNUSED)
4049                 {
4050                         VkImageUsageFlags usage;
4051
4052                         switch (refType)
4053                         {
4054                                 case ATTACHMENTREFTYPE_COLOR:
4055                                 case ATTACHMENTREFTYPE_RESOLVE:
4056                                         usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
4057                                         break;
4058
4059                                 case ATTACHMENTREFTYPE_DEPTH_STENCIL:
4060                                         usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
4061                                         break;
4062
4063                                 case ATTACHMENTREFTYPE_INPUT:
4064                                         usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
4065                                         break;
4066
4067                                 default:
4068                                         DE_FATAL("Unexpected attachment reference type");
4069                                         usage = 0;
4070                                         break;
4071                         }
4072
4073                         attachmentImageUsage[attachment] |= usage;
4074                 }
4075         }
4076 }
4077
4078 void getImageUsageFromAttachmentReferences(vector<VkImageUsageFlags>& attachmentImageUsage, AttachmentRefType refType, const vector<AttachmentReference>& references)
4079 {
4080         if (!references.empty())
4081         {
4082                 getImageUsageFromAttachmentReferences(attachmentImageUsage, refType, references.size(), &references[0]);
4083         }
4084 }
4085
4086 void initializeAttachmentImageUsage (Context &context, vector<VkImageUsageFlags>& attachmentImageUsage, const RenderPass& renderPassInfo, const vector<bool>& attachmentIsLazy, const vector<Maybe<VkClearValue> >& clearValues)
4087 {
4088         attachmentImageUsage.resize(renderPassInfo.getAttachments().size(), VkImageUsageFlags(0));
4089
4090         for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); ++subpassNdx)
4091         {
4092                 const Subpass& subpass = renderPassInfo.getSubpasses()[subpassNdx];
4093
4094                 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_COLOR, subpass.getColorAttachments());
4095                 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_DEPTH_STENCIL, 1, &subpass.getDepthStencilAttachment());
4096                 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_INPUT, subpass.getInputAttachments());
4097                 getImageUsageFromAttachmentReferences(attachmentImageUsage, ATTACHMENTREFTYPE_RESOLVE, subpass.getResolveAttachments());
4098         }
4099
4100         for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
4101         {
4102                 const Attachment& attachment = renderPassInfo.getAttachments()[attachmentNdx];
4103                 const VkFormatProperties        formatProperties        = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), attachment.getFormat());
4104                 const VkFormatFeatureFlags      supportedFeatures       = formatProperties.optimalTilingFeatures;
4105
4106                 if ((supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
4107                         attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_SAMPLED_BIT;
4108
4109                 if ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0)
4110                         attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_STORAGE_BIT;
4111
4112                 attachmentImageUsage[attachmentNdx] |= getImageUsageFromLayout(attachment.getInitialLayout());
4113                 attachmentImageUsage[attachmentNdx] |= getImageUsageFromLayout(attachment.getFinalLayout());
4114
4115                 if (!attachmentIsLazy[attachmentNdx])
4116                 {
4117                         if (clearValues[attachmentNdx])
4118                                 attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
4119
4120                         attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
4121                 }
4122                 else
4123                 {
4124                         const VkImageUsageFlags allowedTransientBits = static_cast<VkImageUsageFlags>(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
4125
4126                         attachmentImageUsage[attachmentNdx] &= allowedTransientBits;
4127                         attachmentImageUsage[attachmentNdx] |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
4128                 }
4129         }
4130 }
4131
4132 void initializeSubpassIsSecondary (vector<bool>& subpassIsSecondary, const vector<Subpass>& subpasses, TestConfig::CommandBufferTypes commandBuffer)
4133 {
4134         bool lastSubpassWasSecondary = false;
4135
4136         for (size_t subpassNdx = 0; subpassNdx < subpasses.size(); subpassNdx++)
4137         {
4138                 if (commandBuffer == TestConfig::COMMANDBUFFERTYPES_SECONDARY || (commandBuffer & TestConfig::COMMANDBUFFERTYPES_SECONDARY && !lastSubpassWasSecondary))
4139                 {
4140                         subpassIsSecondary.push_back(true);
4141                         lastSubpassWasSecondary = true;
4142                 }
4143                 else if (commandBuffer & TestConfig::COMMANDBUFFERTYPES_INLINE)
4144                 {
4145                         subpassIsSecondary.push_back(false);
4146                         lastSubpassWasSecondary = false;
4147                 }
4148                 else
4149                         DE_FATAL("Unknown commandBuffer");
4150         }
4151 }
4152
4153 void initializeImageClearValues (de::Random& rng, vector<Maybe<VkClearValue> >& clearValues, const vector<Attachment>& attachments, const vector<bool>& isLazy)
4154 {
4155         for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
4156         {
4157                 if (!isLazy[attachmentNdx])
4158                         clearValues.push_back(just(randomClearValue(attachments[attachmentNdx], rng)));
4159                 else
4160                         clearValues.push_back(nothing<VkClearValue>());
4161         }
4162 }
4163
4164 void initializeRenderPassClearValues (de::Random& rng, vector<Maybe<VkClearValue> >& clearValues, const vector<Attachment>& attachments)
4165 {
4166         for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
4167         {
4168                 if (attachments[attachmentNdx].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR
4169                         || attachments[attachmentNdx].getStencilLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR)
4170                 {
4171                         clearValues.push_back(just(randomClearValue(attachments[attachmentNdx], rng)));
4172                 }
4173                 else
4174                         clearValues.push_back(nothing<VkClearValue>());
4175         }
4176 }
4177
4178 void initializeSubpassClearValues (de::Random& rng, vector<vector<VkClearColorValue> >& clearValues, const RenderPass& renderPass)
4179 {
4180         clearValues.resize(renderPass.getSubpasses().size());
4181
4182         for (size_t subpassNdx = 0; subpassNdx < renderPass.getSubpasses().size(); subpassNdx++)
4183         {
4184                 const Subpass&                                          subpass                         = renderPass.getSubpasses()[subpassNdx];
4185                 const vector<AttachmentReference>&      colorAttachments        = subpass.getColorAttachments();
4186
4187                 clearValues[subpassNdx].resize(colorAttachments.size());
4188
4189                 for (size_t attachmentRefNdx = 0; attachmentRefNdx < colorAttachments.size(); attachmentRefNdx++)
4190                 {
4191                         const AttachmentReference&      attachmentRef   = colorAttachments[attachmentRefNdx];
4192                         const Attachment&                       attachment              = renderPass.getAttachments()[attachmentRef.getAttachment()];
4193
4194                         clearValues[subpassNdx][attachmentRefNdx] = randomColorClearValue(attachment, rng);
4195                 }
4196         }
4197 }
4198
4199 void logSubpassRenderInfo (TestLog&                                     log,
4200                                                    const SubpassRenderInfo&     info)
4201 {
4202         log << TestLog::Message << "Viewport, offset: " << info.getViewportOffset() << ", size: " << info.getViewportSize() << TestLog::EndMessage;
4203
4204         if (info.isSecondary())
4205                 log << TestLog::Message << "Subpass uses secondary command buffers" << TestLog::EndMessage;
4206         else
4207                 log << TestLog::Message << "Subpass uses inlined commands" << TestLog::EndMessage;
4208
4209         for (deUint32 attachmentNdx = 0; attachmentNdx < info.getColorClears().size(); attachmentNdx++)
4210         {
4211                 const ColorClear&       colorClear      = info.getColorClears()[attachmentNdx];
4212
4213                 log << TestLog::Message << "Clearing color attachment " << attachmentNdx
4214                         << ". Offset: " << colorClear.getOffset()
4215                         << ", Size: " << colorClear.getSize()
4216                         << ", Color: " << clearColorToString(info.getColorAttachment(attachmentNdx).getFormat(), colorClear.getColor()) << TestLog::EndMessage;
4217         }
4218
4219         if (info.getDepthStencilClear())
4220         {
4221                 const DepthStencilClear&        depthStencilClear       = *info.getDepthStencilClear();
4222
4223                 log << TestLog::Message << "Clearing depth stencil attachment"
4224                         << ". Offset: " << depthStencilClear.getOffset()
4225                         << ", Size: " << depthStencilClear.getSize()
4226                         << ", Depth: " << depthStencilClear.getDepth()
4227                         << ", Stencil: " << depthStencilClear.getStencil() << TestLog::EndMessage;
4228         }
4229
4230         if (info.getRenderQuad())
4231         {
4232                 const RenderQuad&       renderQuad      = *info.getRenderQuad();
4233
4234                 log << TestLog::Message << "Rendering grid quad to " << renderQuad.getCornerA() << " -> " << renderQuad.getCornerB() << TestLog::EndMessage;
4235         }
4236 }
4237
4238 void logTestCaseInfo (TestLog&                                                          log,
4239                                           const TestConfig&                                             config,
4240                                           const vector<bool>&                                   attachmentIsLazy,
4241                                           const vector<Maybe<VkClearValue> >&   imageClearValues,
4242                                           const vector<Maybe<VkClearValue> >&   renderPassClearValues,
4243                                           const vector<SubpassRenderInfo>&              subpassRenderInfo)
4244 {
4245         const RenderPass&       renderPass      = config.renderPass;
4246
4247         logRenderPassInfo(log, renderPass);
4248
4249         DE_ASSERT(attachmentIsLazy.size() == renderPass.getAttachments().size());
4250         DE_ASSERT(imageClearValues.size() == renderPass.getAttachments().size());
4251         DE_ASSERT(renderPassClearValues.size() == renderPass.getAttachments().size());
4252
4253         log << TestLog::Message << "TargetSize: " << config.targetSize << TestLog::EndMessage;
4254         log << TestLog::Message << "Render area, Offset: " << config.renderPos << ", Size: " << config.renderSize << TestLog::EndMessage;
4255
4256         for (size_t attachmentNdx = 0; attachmentNdx < attachmentIsLazy.size(); attachmentNdx++)
4257         {
4258                 const tcu::ScopedLogSection     section (log, "Attachment" + de::toString(attachmentNdx), "Attachment " + de::toString(attachmentNdx));
4259
4260                 if (attachmentIsLazy[attachmentNdx])
4261                         log << TestLog::Message << "Is lazy." << TestLog::EndMessage;
4262
4263                 if (imageClearValues[attachmentNdx])
4264                         log << TestLog::Message << "Image is cleared to " << clearValueToString(renderPass.getAttachments()[attachmentNdx].getFormat(), *imageClearValues[attachmentNdx]) << " before rendering." << TestLog::EndMessage;
4265
4266                 if (renderPass.getAttachments()[attachmentNdx].getLoadOp() == VK_ATTACHMENT_LOAD_OP_CLEAR && renderPassClearValues[attachmentNdx])
4267                         log << TestLog::Message << "Attachment is cleared to " << clearValueToString(renderPass.getAttachments()[attachmentNdx].getFormat(), *renderPassClearValues[attachmentNdx]) << " in the beginning of the render pass." << TestLog::EndMessage;
4268         }
4269
4270         for (size_t subpassNdx = 0; subpassNdx < renderPass.getSubpasses().size(); subpassNdx++)
4271         {
4272                 const tcu::ScopedLogSection section (log, "Subpass" + de::toString(subpassNdx), "Subpass " + de::toString(subpassNdx));
4273
4274                 logSubpassRenderInfo(log, subpassRenderInfo[subpassNdx]);
4275         }
4276 }
4277
4278 float roundToViewport (float x, deUint32 offset, deUint32 size)
4279 {
4280         const float             origin  = (float)(offset) + ((float(size) / 2.0f));
4281         const float             p               = (float)(size) / 2.0f;
4282         const deInt32   xi              = deRoundFloatToInt32(origin + (p * x));
4283
4284         return (((float)xi) - origin) / p;
4285 }
4286
4287 void initializeSubpassRenderInfo (vector<SubpassRenderInfo>& renderInfos, de::Random& rng, const RenderPass& renderPass, const TestConfig& config)
4288 {
4289         const TestConfig::CommandBufferTypes    commandBuffer                   = config.commandBufferTypes;
4290         const vector<Subpass>&                                  subpasses                               = renderPass.getSubpasses();
4291         bool                                                                    lastSubpassWasSecondary = false;
4292
4293         for (deUint32 subpassNdx = 0; subpassNdx < (deUint32)subpasses.size(); subpassNdx++)
4294         {
4295                 const Subpass&                          subpass                         = subpasses[subpassNdx];
4296                 const bool                                      subpassIsSecondary      = commandBuffer == TestConfig::COMMANDBUFFERTYPES_SECONDARY
4297                                                                                                                 || (commandBuffer & TestConfig::COMMANDBUFFERTYPES_SECONDARY && !lastSubpassWasSecondary) ? true : false;
4298                 const UVec2                                     viewportSize            ((config.renderSize * UVec2(2)) / UVec2(3));
4299                 const UVec2                                     viewportOffset          (config.renderPos.x() + (subpassNdx % 2) * (config.renderSize.x() / 3),
4300                                                                                                                  config.renderPos.y() + ((subpassNdx / 2) % 2) * (config.renderSize.y() / 3));
4301
4302                 vector<ColorClear>                      colorClears;
4303                 Maybe<DepthStencilClear>        depthStencilClear;
4304                 Maybe<RenderQuad>                       renderQuad;
4305
4306                 lastSubpassWasSecondary         = subpassIsSecondary;
4307
4308                 if (config.renderTypes & TestConfig::RENDERTYPES_CLEAR)
4309                 {
4310                         const vector<AttachmentReference>&      colorAttachments        = subpass.getColorAttachments();
4311
4312                         for (size_t attachmentRefNdx = 0; attachmentRefNdx < colorAttachments.size(); attachmentRefNdx++)
4313                         {
4314                                 const AttachmentReference&      attachmentRef   = colorAttachments[attachmentRefNdx];
4315                                 const Attachment&                       attachment              = renderPass.getAttachments()[attachmentRef.getAttachment()];
4316                                 const UVec2                                     size                    ((viewportSize * UVec2(2)) / UVec2(3));
4317                                 const UVec2                                     offset                  (viewportOffset.x() + ((deUint32)attachmentRefNdx % 2u) * (viewportSize.x() / 3u),
4318                                                                                                                          viewportOffset.y() + (((deUint32)attachmentRefNdx / 2u) % 2u) * (viewportSize.y() / 3u));
4319                                 const VkClearColorValue         color                   = randomColorClearValue(attachment, rng);
4320
4321                                 colorClears.push_back(ColorClear(offset, size, color));
4322                         }
4323
4324                         if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED)
4325                         {
4326                                 const Attachment&       attachment      = renderPass.getAttachments()[subpass.getDepthStencilAttachment().getAttachment()];
4327                                 const UVec2                     size            ((viewportSize * UVec2(2)) / UVec2(3));
4328                                 const UVec2                     offset          (viewportOffset.x() + ((deUint32)colorAttachments.size() % 2u) * (viewportSize.x() / 3u),
4329                                                                                                  viewportOffset.y() + (((deUint32)colorAttachments.size() / 2u) % 2u) * (viewportSize.y() / 3u));
4330                                 const VkClearValue      value           = randomClearValue(attachment, rng);
4331
4332                                 depthStencilClear = tcu::just(DepthStencilClear(offset, size, value.depthStencil.depth, value.depthStencil.stencil));
4333                         }
4334                 }
4335
4336                 if (config.renderTypes & TestConfig::RENDERTYPES_DRAW)
4337                 {
4338                         const float     w       = (subpassNdx % 2) == 0 ? 1.0f : 1.25f;
4339                         const float     h       = (subpassNdx % 2) == 0 ? 1.25f : 1.0f;
4340
4341                         const float     x0      = roundToViewport((subpassNdx % 2) == 0 ? 1.0f - w : -1.0f, viewportOffset.x(), viewportSize.x());
4342                         const float     x1      = roundToViewport((subpassNdx % 2) == 0 ? 1.0f : -1.0f + w, viewportOffset.x(), viewportSize.x());
4343
4344                         const float     y0      = roundToViewport(((subpassNdx / 2) % 2) == 0 ? 1.0f - h : -1.0f, viewportOffset.y(), viewportSize.y());
4345                         const float     y1      = roundToViewport(((subpassNdx / 2) % 2) == 0 ? 1.0f : -1.0f + h, viewportOffset.y(), viewportSize.y());
4346
4347                         renderQuad = tcu::just(RenderQuad(tcu::Vec2(x0, y0), tcu::Vec2(x1, y1)));
4348                 }
4349
4350                 renderInfos.push_back(SubpassRenderInfo(renderPass, subpassNdx, subpassIsSecondary, viewportOffset, viewportSize, renderQuad, colorClears, depthStencilClear));
4351         }
4352 }
4353
4354 void checkTextureFormatSupport (TestLog&                                        log,
4355                                                                 const InstanceInterface&        vk,
4356                                                                 VkPhysicalDevice                        device,
4357                                                                 const vector<Attachment>&       attachments)
4358 {
4359         bool supported = true;
4360
4361         for (size_t attachmentNdx = 0; attachmentNdx < attachments.size(); attachmentNdx++)
4362         {
4363                 const Attachment&                       attachment                                      = attachments[attachmentNdx];
4364                 const tcu::TextureFormat        format                                          = mapVkFormat(attachment.getFormat());
4365                 const bool                                      isDepthOrStencilAttachment      = hasDepthComponent(format.order) || hasStencilComponent(format.order);
4366                 const VkFormatFeatureFlags      flags                                           = isDepthOrStencilAttachment? VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT : VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
4367                 VkFormatProperties                      properties;
4368
4369                 vk.getPhysicalDeviceFormatProperties(device, attachment.getFormat(), &properties);
4370
4371                 if ((properties.optimalTilingFeatures & flags) != flags)
4372                 {
4373                         supported = false;
4374                         log << TestLog::Message << "Format: " << attachment.getFormat() << " not supported as " << (isDepthOrStencilAttachment ? "depth stencil attachment" : "color attachment") << TestLog::EndMessage;
4375                 }
4376         }
4377
4378         if (!supported)
4379                 TCU_THROW(NotSupportedError, "Format not supported");
4380 }
4381
4382 tcu::TestStatus renderPassTest (Context& context, TestConfig config)
4383 {
4384         const UVec2                                                     targetSize                      = config.targetSize;
4385         const UVec2                                                     renderPos                       = config.renderPos;
4386         const UVec2                                                     renderSize                      = config.renderSize;
4387         const RenderPass&                                       renderPassInfo          = config.renderPass;
4388
4389         TestLog&                                                        log                                     = context.getTestContext().getLog();
4390         de::Random                                                      rng                                     (config.seed);
4391
4392         vector<bool>                                            attachmentIsLazy;
4393         vector<VkImageUsageFlags>                       attachmentImageUsage;
4394         vector<Maybe<VkClearValue> >            imageClearValues;
4395         vector<Maybe<VkClearValue> >            renderPassClearValues;
4396
4397         vector<bool>                                            subpassIsSecondary;
4398         vector<SubpassRenderInfo>                       subpassRenderInfo;
4399         vector<vector<VkClearColorValue> >      subpassColorClearValues;
4400
4401         if (config.allocationKind == ALLOCATION_KIND_DEDICATED)
4402         {
4403                 if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
4404                         TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
4405         }
4406
4407         if (!renderPassInfo.getInputAspects().empty())
4408         {
4409                 if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
4410                         TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported.");
4411         }
4412
4413         {
4414                 bool requireDepthStencilLayout = false;
4415
4416                 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
4417                 {
4418                         if (renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
4419                                 || renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
4420                                 || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
4421                                 || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4422                         {
4423                                 requireDepthStencilLayout = true;
4424                                 break;
4425                         }
4426                 }
4427
4428                 for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size() && !requireDepthStencilLayout; subpassNdx++)
4429                 {
4430                         const Subpass& subpass (renderPassInfo.getSubpasses()[subpassNdx]);
4431
4432                         for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
4433                         {
4434                                 if (subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
4435                                         || subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4436                                 {
4437                                         requireDepthStencilLayout = true;
4438                                         break;
4439                                 }
4440                         }
4441
4442                         for (size_t attachmentNdx = 0; !requireDepthStencilLayout && attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
4443                         {
4444                                 if (subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
4445                                         || subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4446                                 {
4447                                         requireDepthStencilLayout = true;
4448                                         break;
4449                                 }
4450                         }
4451
4452                         for (size_t attachmentNdx = 0; !requireDepthStencilLayout && attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++)
4453                         {
4454                                 if (subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
4455                                         || subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4456                                 {
4457                                         requireDepthStencilLayout = true;
4458                                         break;
4459                                 }
4460                         }
4461
4462                         if (subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
4463                                 || subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
4464                         {
4465                                 requireDepthStencilLayout = true;
4466                                 break;
4467                         }
4468                 }
4469
4470                 if (requireDepthStencilLayout && !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
4471                         TCU_THROW(NotSupportedError, "VK_KHR_maintenance2 is not supported");
4472         }
4473
4474         initializeAttachmentIsLazy(attachmentIsLazy, renderPassInfo.getAttachments(), config.imageMemory);
4475         initializeImageClearValues(rng, imageClearValues, renderPassInfo.getAttachments(), attachmentIsLazy);
4476         initializeAttachmentImageUsage(context, attachmentImageUsage, renderPassInfo, attachmentIsLazy, imageClearValues);
4477         initializeRenderPassClearValues(rng, renderPassClearValues, renderPassInfo.getAttachments());
4478
4479         initializeSubpassIsSecondary(subpassIsSecondary, renderPassInfo.getSubpasses(), config.commandBufferTypes);
4480         initializeSubpassClearValues(rng, subpassColorClearValues, renderPassInfo);
4481         initializeSubpassRenderInfo(subpassRenderInfo, rng, renderPassInfo, config);
4482
4483         logTestCaseInfo(log, config, attachmentIsLazy, imageClearValues, renderPassClearValues, subpassRenderInfo);
4484
4485         checkTextureFormatSupport(log, context.getInstanceInterface(), context.getPhysicalDevice(), config.renderPass.getAttachments());
4486
4487         {
4488                 const vk::VkPhysicalDeviceProperties properties = vk::getPhysicalDeviceProperties(context.getInstanceInterface(), context.getPhysicalDevice());
4489
4490                 log << TestLog::Message << "Max color attachments: " << properties.limits.maxColorAttachments << TestLog::EndMessage;
4491
4492                 for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
4493                 {
4494                          if (renderPassInfo.getSubpasses()[subpassNdx].getColorAttachments().size() > (size_t)properties.limits.maxColorAttachments)
4495                                  TCU_THROW(NotSupportedError, "Subpass uses more than maxColorAttachments.");
4496                 }
4497         }
4498
4499         {
4500                 const InstanceInterface&                                        vki                                                                     = context.getInstanceInterface();
4501                 const VkPhysicalDevice&                                         physDevice                                                      = context.getPhysicalDevice();
4502                 const VkDevice                                                          device                                                          = context.getDevice();
4503                 const DeviceInterface&                                          vk                                                                      = context.getDeviceInterface();
4504                 const VkQueue                                                           queue                                                           = context.getUniversalQueue();
4505                 const deUint32                                                          queueIndex                                                      = context.getUniversalQueueFamilyIndex();
4506                 Allocator&                                                                      allocator                                                       = context.getDefaultAllocator();
4507
4508                 const Unique<VkRenderPass>                                      renderPass                                                      (createRenderPass(vk, device, renderPassInfo));
4509                 const Unique<VkCommandPool>                                     commandBufferPool                                       (createCommandPool(vk, device, queueIndex, 0));
4510                 const Unique<VkCommandBuffer>                           initializeImagesCommandBuffer           (allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
4511                 const Unique<VkCommandBuffer>                           renderCommandBuffer                                     (allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
4512                 const Unique<VkCommandBuffer>                           readImagesToBuffersCommandBuffer        (allocateCommandBuffer(vk, device, *commandBufferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
4513
4514                 vector<de::SharedPtr<AttachmentResources> >     attachmentResources;
4515                 vector<de::SharedPtr<SubpassRenderer> >         subpassRenderers;
4516                 vector<VkImage>                                                         attachmentImages;
4517                 vector<VkImageView>                                                     attachmentViews;
4518                 vector<pair<VkImageView, VkImageView> >         inputAttachmentViews;
4519
4520                 for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
4521                 {
4522                         const Attachment&       attachmentInfo  = renderPassInfo.getAttachments()[attachmentNdx];
4523
4524                         attachmentResources.push_back(de::SharedPtr<AttachmentResources>(new AttachmentResources(vki, physDevice, vk, device, allocator, queueIndex, targetSize, attachmentInfo, attachmentImageUsage[attachmentNdx], config.allocationKind)));
4525                         attachmentViews.push_back(attachmentResources[attachmentNdx]->getAttachmentView());
4526                         attachmentImages.push_back(attachmentResources[attachmentNdx]->getImage());
4527
4528                         inputAttachmentViews.push_back(attachmentResources[attachmentNdx]->getInputAttachmentViews());
4529                 }
4530
4531                 beginCommandBuffer(vk, *initializeImagesCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
4532                 pushImageInitializationCommands(vk, *initializeImagesCommandBuffer, renderPassInfo.getAttachments(), attachmentResources, queueIndex, imageClearValues);
4533                 endCommandBuffer(vk, *initializeImagesCommandBuffer);
4534
4535                 {
4536                         const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, device, *renderPass, targetSize, attachmentViews));
4537
4538                         for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
4539                                 subpassRenderers.push_back(de::SharedPtr<SubpassRenderer>(new SubpassRenderer(context, vk, device, allocator, *renderPass, *framebuffer, *commandBufferPool, queueIndex, attachmentImages, inputAttachmentViews, subpassRenderInfo[subpassNdx], config.renderPass.getAttachments(), config.allocationKind)));
4540
4541                         beginCommandBuffer(vk, *renderCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
4542                         pushRenderPassCommands(vk, *renderCommandBuffer, *renderPass, *framebuffer, subpassRenderers, renderPos, renderSize, renderPassClearValues, config.renderTypes);
4543                         endCommandBuffer(vk, *renderCommandBuffer);
4544
4545                         beginCommandBuffer(vk, *readImagesToBuffersCommandBuffer, (VkCommandBufferUsageFlags)0, DE_NULL, 0, DE_NULL, VK_FALSE, (VkQueryControlFlags)0, (VkQueryPipelineStatisticFlags)0);
4546                         pushReadImagesToBuffers(vk, *readImagesToBuffersCommandBuffer, queueIndex, attachmentResources, renderPassInfo.getAttachments(), attachmentIsLazy, targetSize);
4547                         endCommandBuffer(vk, *readImagesToBuffersCommandBuffer);
4548                         {
4549                                 const VkCommandBuffer commandBuffers[] =
4550                                 {
4551                                         *initializeImagesCommandBuffer,
4552                                         *renderCommandBuffer,
4553                                         *readImagesToBuffersCommandBuffer
4554                                 };
4555                                 const Unique<VkFence>   fence           (createFence(vk, device, 0u));
4556
4557                                 queueSubmit(vk, queue, DE_LENGTH_OF_ARRAY(commandBuffers), commandBuffers, *fence);
4558                                 waitForFences(vk, device, 1, &fence.get(), VK_TRUE, ~0ull);
4559                         }
4560                 }
4561
4562                 if (logAndVerifyImages(log, vk, device, attachmentResources, attachmentIsLazy, renderPassInfo, renderPassClearValues, imageClearValues, subpassRenderInfo, targetSize, config))
4563                         return tcu::TestStatus::pass("Pass");
4564                 else
4565                         return tcu::TestStatus::fail("Result verification failed");
4566         }
4567 }
4568
4569 static const VkFormat s_coreColorFormats[] =
4570 {
4571         VK_FORMAT_R5G6B5_UNORM_PACK16,
4572         VK_FORMAT_R8_UNORM,
4573         VK_FORMAT_R8_SNORM,
4574         VK_FORMAT_R8_UINT,
4575         VK_FORMAT_R8_SINT,
4576         VK_FORMAT_R8G8_UNORM,
4577         VK_FORMAT_R8G8_SNORM,
4578         VK_FORMAT_R8G8_UINT,
4579         VK_FORMAT_R8G8_SINT,
4580         VK_FORMAT_R8G8B8A8_UNORM,
4581         VK_FORMAT_R8G8B8A8_SNORM,
4582         VK_FORMAT_R8G8B8A8_UINT,
4583         VK_FORMAT_R8G8B8A8_SINT,
4584         VK_FORMAT_R8G8B8A8_SRGB,
4585         VK_FORMAT_A8B8G8R8_UNORM_PACK32,
4586         VK_FORMAT_A8B8G8R8_SNORM_PACK32,
4587         VK_FORMAT_A8B8G8R8_UINT_PACK32,
4588         VK_FORMAT_A8B8G8R8_SINT_PACK32,
4589         VK_FORMAT_A8B8G8R8_SRGB_PACK32,
4590         VK_FORMAT_B8G8R8A8_UNORM,
4591         VK_FORMAT_B8G8R8A8_SRGB,
4592         VK_FORMAT_A2R10G10B10_UNORM_PACK32,
4593         VK_FORMAT_A2B10G10R10_UNORM_PACK32,
4594         VK_FORMAT_A2B10G10R10_UINT_PACK32,
4595         VK_FORMAT_R16_UNORM,
4596         VK_FORMAT_R16_SNORM,
4597         VK_FORMAT_R16_UINT,
4598         VK_FORMAT_R16_SINT,
4599         VK_FORMAT_R16_SFLOAT,
4600         VK_FORMAT_R16G16_UNORM,
4601         VK_FORMAT_R16G16_SNORM,
4602         VK_FORMAT_R16G16_UINT,
4603         VK_FORMAT_R16G16_SINT,
4604         VK_FORMAT_R16G16_SFLOAT,
4605         VK_FORMAT_R16G16B16A16_UNORM,
4606         VK_FORMAT_R16G16B16A16_SNORM,
4607         VK_FORMAT_R16G16B16A16_UINT,
4608         VK_FORMAT_R16G16B16A16_SINT,
4609         VK_FORMAT_R16G16B16A16_SFLOAT,
4610         VK_FORMAT_R32_UINT,
4611         VK_FORMAT_R32_SINT,
4612         VK_FORMAT_R32_SFLOAT,
4613         VK_FORMAT_R32G32_UINT,
4614         VK_FORMAT_R32G32_SINT,
4615         VK_FORMAT_R32G32_SFLOAT,
4616         VK_FORMAT_R32G32B32A32_UINT,
4617         VK_FORMAT_R32G32B32A32_SINT,
4618         VK_FORMAT_R32G32B32A32_SFLOAT
4619 };
4620
4621 static const VkFormat s_coreDepthStencilFormats[] =
4622 {
4623         VK_FORMAT_D16_UNORM,
4624
4625         VK_FORMAT_X8_D24_UNORM_PACK32,
4626         VK_FORMAT_D32_SFLOAT,
4627
4628         VK_FORMAT_D24_UNORM_S8_UINT,
4629         VK_FORMAT_D32_SFLOAT_S8_UINT
4630 };
4631
4632 void addAttachmentTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
4633 {
4634         const deUint32 attachmentCounts[] = { 1, 3, 4, 8 };
4635         const VkAttachmentLoadOp loadOps[] =
4636         {
4637                 VK_ATTACHMENT_LOAD_OP_LOAD,
4638                 VK_ATTACHMENT_LOAD_OP_CLEAR,
4639                 VK_ATTACHMENT_LOAD_OP_DONT_CARE
4640         };
4641
4642         const VkAttachmentStoreOp storeOps[] =
4643         {
4644                 VK_ATTACHMENT_STORE_OP_STORE,
4645                 VK_ATTACHMENT_STORE_OP_DONT_CARE
4646         };
4647
4648         const VkImageLayout initialAndFinalColorLayouts[] =
4649         {
4650                 VK_IMAGE_LAYOUT_GENERAL,
4651                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
4652                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
4653                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4654                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
4655         };
4656
4657         const VkImageLayout initialAndFinalDepthStencilLayouts[] =
4658         {
4659                 VK_IMAGE_LAYOUT_GENERAL,
4660                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
4661                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
4662                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
4663                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4664                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
4665         };
4666
4667         const VkImageLayout subpassLayouts[] =
4668         {
4669                 VK_IMAGE_LAYOUT_GENERAL,
4670                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
4671         };
4672
4673         const VkImageLayout depthStencilLayouts[] =
4674         {
4675                 VK_IMAGE_LAYOUT_GENERAL,
4676                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
4677         };
4678
4679         const TestConfig::RenderTypes renderCommands[] =
4680         {
4681                 TestConfig::RENDERTYPES_NONE,
4682                 TestConfig::RENDERTYPES_CLEAR,
4683                 TestConfig::RENDERTYPES_DRAW,
4684                 TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW,
4685         };
4686
4687         const TestConfig::CommandBufferTypes commandBuffers[] =
4688         {
4689                 TestConfig::COMMANDBUFFERTYPES_INLINE,
4690                 TestConfig::COMMANDBUFFERTYPES_SECONDARY,
4691                 TestConfig::COMMANDBUFFERTYPES_INLINE|TestConfig::COMMANDBUFFERTYPES_SECONDARY
4692         };
4693
4694         const TestConfig::ImageMemory imageMemories[] =
4695         {
4696                 TestConfig::IMAGEMEMORY_STRICT,
4697                 TestConfig::IMAGEMEMORY_LAZY,
4698                 TestConfig::IMAGEMEMORY_STRICT|TestConfig::IMAGEMEMORY_LAZY
4699         };
4700
4701         const UVec2 targetSizes[] =
4702         {
4703                 UVec2(64, 64),
4704                 UVec2(63, 65)
4705         };
4706
4707         const UVec2 renderPositions[] =
4708         {
4709                 UVec2(0, 0),
4710                 UVec2(3, 17)
4711         };
4712
4713         const UVec2 renderSizes[] =
4714         {
4715                 UVec2(32, 32),
4716                 UVec2(60, 47)
4717         };
4718
4719         tcu::TestContext&       testCtx = group->getTestContext();
4720         de::Random                      rng             (1433774382u);
4721
4722         for (size_t attachmentCountNdx = 0; attachmentCountNdx < DE_LENGTH_OF_ARRAY(attachmentCounts); attachmentCountNdx++)
4723         {
4724                 const deUint32                                  attachmentCount                 = attachmentCounts[attachmentCountNdx];
4725                 const deUint32                                  testCaseCount                   = (attachmentCount == 1 ? 100 : 200);
4726                 de::MovePtr<tcu::TestCaseGroup> attachmentCountGroup    (new tcu::TestCaseGroup(testCtx, de::toString(attachmentCount).c_str(), de::toString(attachmentCount).c_str()));
4727
4728                 for (size_t testCaseNdx = 0; testCaseNdx < testCaseCount; testCaseNdx++)
4729                 {
4730                         const bool                                      useDepthStencil         = rng.getBool();
4731                         VkImageLayout                           depthStencilLayout      = VK_IMAGE_LAYOUT_GENERAL;
4732                         vector<Attachment>                      attachments;
4733                         vector<AttachmentReference>     colorAttachmentReferences;
4734
4735                         for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount; attachmentNdx++)
4736                         {
4737                                 const VkSampleCountFlagBits     sampleCount             = VK_SAMPLE_COUNT_1_BIT;
4738                                 const VkFormat                          format                  = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
4739                                 const VkAttachmentLoadOp        loadOp                  = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
4740                                 const VkAttachmentStoreOp       storeOp                 = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
4741
4742                                 const VkImageLayout                     initialLayout   = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
4743                                 const VkImageLayout                     finalizeLayout  = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
4744                                 const VkImageLayout                     subpassLayout   = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
4745
4746                                 const VkAttachmentLoadOp        stencilLoadOp   = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
4747                                 const VkAttachmentStoreOp       stencilStoreOp  = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
4748
4749                                 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
4750                                 colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
4751                         }
4752
4753                         if (useDepthStencil)
4754                         {
4755                                 const VkSampleCountFlagBits     sampleCount             = VK_SAMPLE_COUNT_1_BIT;
4756                                 const VkFormat                          format                  = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreDepthStencilFormats), DE_ARRAY_END(s_coreDepthStencilFormats));
4757                                 const VkAttachmentLoadOp        loadOp                  = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
4758                                 const VkAttachmentStoreOp       storeOp                 = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
4759
4760                                 const VkImageLayout                     initialLayout   = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts));
4761                                 const VkImageLayout                     finalizeLayout  = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts));
4762
4763                                 const VkAttachmentLoadOp        stencilLoadOp   = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
4764                                 const VkAttachmentStoreOp       stencilStoreOp  = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
4765
4766                                 depthStencilLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(depthStencilLayouts), DE_ARRAY_END(depthStencilLayouts));
4767                                 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
4768                         }
4769
4770                         {
4771                                 const TestConfig::RenderTypes                   render                  = rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
4772                                 const TestConfig::CommandBufferTypes    commandBuffer   = rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
4773                                 const TestConfig::ImageMemory                   imageMemory             = rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
4774                                 const vector<Subpass>                                   subpasses               (1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u, vector<AttachmentReference>(), colorAttachmentReferences, vector<AttachmentReference>(), AttachmentReference((useDepthStencil ? (deUint32)(attachments.size() - 1) : VK_ATTACHMENT_UNUSED), depthStencilLayout), vector<deUint32>()));
4775                                 const vector<SubpassDependency>                 deps;
4776
4777                                 const string                                                    testCaseName    = de::toString(attachmentCountNdx * testCaseCount + testCaseNdx);
4778                                 const RenderPass                                                renderPass              (attachments, subpasses, deps);
4779                                 const UVec2                                                             targetSize              = rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
4780                                 const UVec2                                                             renderPos               = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
4781                                 const UVec2                                                             renderSize              = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
4782
4783                                 addFunctionCaseWithPrograms<TestConfig>(attachmentCountGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, TestConfig(renderPass, render, commandBuffer, imageMemory, targetSize, renderPos, renderSize, 1293809, allocationKind));
4784                         }
4785                 }
4786
4787                 group->addChild(attachmentCountGroup.release());
4788         }
4789 }
4790
4791 template<typename T>
4792 T chooseRandom (de::Random& rng, const set<T>& values)
4793 {
4794         size_t                                                  ndx             = ((size_t)rng.getUint32()) % values.size();
4795         typename set<T>::const_iterator iter    = values.begin();
4796
4797         for (; ndx > 0; ndx--)
4798                 iter++;
4799
4800         return *iter;
4801 }
4802
4803 void addAttachmentAllocationTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
4804 {
4805         const deUint32 attachmentCounts[] = { 4, 8 };
4806         const VkAttachmentLoadOp loadOps[] =
4807         {
4808                 VK_ATTACHMENT_LOAD_OP_LOAD,
4809                 VK_ATTACHMENT_LOAD_OP_CLEAR,
4810                 VK_ATTACHMENT_LOAD_OP_DONT_CARE
4811         };
4812
4813         const VkAttachmentStoreOp storeOps[] =
4814         {
4815                 VK_ATTACHMENT_STORE_OP_STORE,
4816                 VK_ATTACHMENT_STORE_OP_DONT_CARE
4817         };
4818
4819         const VkImageLayout initialAndFinalColorLayouts[] =
4820         {
4821                 VK_IMAGE_LAYOUT_GENERAL,
4822                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
4823                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
4824                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4825                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
4826         };
4827
4828         const VkImageLayout initialAndFinalDepthStencilLayouts[] =
4829         {
4830                 VK_IMAGE_LAYOUT_GENERAL,
4831                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
4832                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
4833                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
4834                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
4835                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
4836         };
4837
4838         const VkImageLayout subpassLayouts[] =
4839         {
4840                 VK_IMAGE_LAYOUT_GENERAL,
4841                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
4842         };
4843
4844         enum AllocationType
4845         {
4846                 // Each pass uses one more attachmen than previous one
4847                 ALLOCATIONTYPE_GROW,
4848                 // Each pass uses one less attachment than previous one
4849                 ALLOCATIONTYPE_SHRINK,
4850                 // Each pass drops one attachment and picks up new one
4851                 ALLOCATIONTYPE_ROLL,
4852                 // Start by growing and end by shrinking
4853                 ALLOCATIONTYPE_GROW_SHRINK,
4854                 // Each subpass has single input and single output attachment
4855                 ALLOCATIONTYPE_IO_CHAIN,
4856                 // Each subpass has multiple inputs and multiple outputs attachment
4857                 ALLOCATIONTYPE_IO_GENERIC
4858         };
4859
4860         const AllocationType allocationTypes[] =
4861         {
4862                 ALLOCATIONTYPE_GROW,
4863                 ALLOCATIONTYPE_SHRINK,
4864                 ALLOCATIONTYPE_ROLL,
4865                 ALLOCATIONTYPE_GROW_SHRINK,
4866                 ALLOCATIONTYPE_IO_CHAIN,
4867                 ALLOCATIONTYPE_IO_GENERIC
4868         };
4869
4870         const char* const allocationTypeStr[] =
4871         {
4872                 "grow",
4873                 "shrink",
4874                 "roll",
4875                 "grow_shrink",
4876                 "input_output_chain",
4877                 "input_output",
4878         };
4879
4880         const TestConfig::RenderTypes renderCommands[] =
4881         {
4882                 TestConfig::RENDERTYPES_NONE,
4883                 TestConfig::RENDERTYPES_CLEAR,
4884                 TestConfig::RENDERTYPES_DRAW,
4885                 TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW,
4886         };
4887
4888         const TestConfig::CommandBufferTypes commandBuffers[] =
4889         {
4890                 TestConfig::COMMANDBUFFERTYPES_INLINE,
4891                 TestConfig::COMMANDBUFFERTYPES_SECONDARY,
4892                 TestConfig::COMMANDBUFFERTYPES_INLINE|TestConfig::COMMANDBUFFERTYPES_SECONDARY
4893         };
4894
4895         const TestConfig::ImageMemory imageMemories[] =
4896         {
4897                 TestConfig::IMAGEMEMORY_STRICT,
4898                 TestConfig::IMAGEMEMORY_LAZY,
4899                 TestConfig::IMAGEMEMORY_STRICT|TestConfig::IMAGEMEMORY_LAZY
4900         };
4901
4902         const UVec2 targetSizes[] =
4903         {
4904                 UVec2(64, 64),
4905                 UVec2(63, 65)
4906         };
4907
4908         const UVec2 renderPositions[] =
4909         {
4910                 UVec2(0, 0),
4911                 UVec2(3, 17)
4912         };
4913
4914         const UVec2 renderSizes[] =
4915         {
4916                 UVec2(32, 32),
4917                 UVec2(60, 47)
4918         };
4919
4920         tcu::TestContext&                               testCtx = group->getTestContext();
4921         de::Random                                              rng             (3700649827u);
4922
4923         for (size_t allocationTypeNdx = 0; allocationTypeNdx < DE_LENGTH_OF_ARRAY(allocationTypes); allocationTypeNdx++)
4924         {
4925                 const AllocationType                    allocationType          = allocationTypes[allocationTypeNdx];
4926                 const size_t                                    testCaseCount           = 100;
4927                 de::MovePtr<tcu::TestCaseGroup> allocationTypeGroup     (new tcu::TestCaseGroup(testCtx, allocationTypeStr[allocationTypeNdx], allocationTypeStr[allocationTypeNdx]));
4928
4929                 for (size_t testCaseNdx = 0; testCaseNdx < testCaseCount; testCaseNdx++)
4930                 {
4931                         if (allocationType == ALLOCATIONTYPE_IO_GENERIC)
4932                         {
4933                                 const deUint32          attachmentCount = 4u + rng.getUint32() % 31u;
4934                                 const deUint32          subpassCount    = 4u + rng.getUint32() % 31u;
4935                                 vector<Attachment>      attachments;
4936
4937                                 set<deUint32>           definedAttachments;
4938
4939                                 vector<Subpass>         subpasses;
4940                                 set<deUint32>           colorAttachments;
4941                                 set<deUint32>           depthStencilAttachments;
4942
4943                                 for (deUint32 attachmentIndex = 0; attachmentIndex < attachmentCount; attachmentIndex++)
4944                                 {
4945                                         const bool                                      isDepthStencilAttachment        = rng.getFloat() < 0.01f;
4946                                         const VkSampleCountFlagBits     sampleCount                                     = VK_SAMPLE_COUNT_1_BIT;
4947                                         const VkAttachmentLoadOp        loadOp                                          = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
4948                                         const VkAttachmentStoreOp       storeOp                                         = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
4949
4950                                         const VkImageLayout                     initialLayout                           = isDepthStencilAttachment
4951                                                                                                                                                         ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts))
4952                                                                                                                                                         : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
4953                                         const VkImageLayout                     finalizeLayout                          = isDepthStencilAttachment
4954                                                                                                                                                         ? rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalDepthStencilLayouts), DE_ARRAY_END(initialAndFinalDepthStencilLayouts))
4955                                                                                                                                                         : rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
4956
4957                                         const VkAttachmentLoadOp        stencilLoadOp                           = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
4958                                         const VkAttachmentStoreOp       stencilStoreOp                          = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
4959
4960                                         if (isDepthStencilAttachment)
4961                                         {
4962                                                 const VkFormat  format  = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreDepthStencilFormats), DE_ARRAY_END(s_coreDepthStencilFormats));
4963
4964                                                 if (loadOp == VK_ATTACHMENT_LOAD_OP_LOAD || loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR
4965                                                         || stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD || stencilLoadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
4966                                                         definedAttachments.insert(attachmentIndex);
4967
4968                                                 depthStencilAttachments.insert(attachmentIndex);
4969
4970                                                 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
4971                                         }
4972                                         else
4973                                         {
4974                                                 const VkFormat  format  = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
4975
4976                                                 if (loadOp == VK_ATTACHMENT_LOAD_OP_LOAD || loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
4977                                                         definedAttachments.insert(attachmentIndex);
4978
4979                                                 colorAttachments.insert(attachmentIndex);
4980
4981                                                 attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
4982                                         }
4983                                 }
4984                                 vector<Maybe<deUint32> >        lastUseOfAttachment     (attachments.size(), nothing<deUint32>());
4985                                 vector<SubpassDependency>       deps;
4986
4987                                 for (deUint32 subpassIndex = 0; subpassIndex < subpassCount; subpassIndex++)
4988                                 {
4989                                         const deUint32                          colorAttachmentCount            = depthStencilAttachments.empty()
4990                                                                                                                                                         ? 1 + rng.getUint32() % de::min(4u, (deUint32)colorAttachments.size())
4991                                                                                                                                                         : rng.getUint32() % (de::min(4u, (deUint32)colorAttachments.size()) + 1u);
4992                                         const deUint32                          inputAttachmentCount            = rng.getUint32() % (deUint32)(de::min<size_t>(4, definedAttachments.size()) + 1);
4993                                         const bool                                      useDepthStencilAttachment       = !depthStencilAttachments.empty() && (colorAttachmentCount == 0 || rng.getBool());
4994                                         std::vector<deUint32>           subpassColorAttachments         (colorAttachmentCount);
4995                                         std::vector<deUint32>           subpassInputAttachments         (inputAttachmentCount);
4996                                         Maybe<deUint32>                         depthStencilAttachment          (useDepthStencilAttachment
4997                                                                                                                                                         ? just(chooseRandom(rng, depthStencilAttachments))
4998                                                                                                                                                         : nothing<deUint32>());
4999                                         std::vector<deUint32>           subpassPreserveAttachments;
5000
5001                                         rng.choose(colorAttachments.begin(), colorAttachments.end(), subpassColorAttachments.begin(), colorAttachmentCount);
5002                                         rng.choose(definedAttachments.begin(), definedAttachments.end(), subpassInputAttachments.begin(), inputAttachmentCount);
5003
5004                                         for (size_t colorAttachmentNdx = 0; colorAttachmentNdx < subpassColorAttachments.size(); colorAttachmentNdx++)
5005                                                 definedAttachments.insert(subpassColorAttachments[colorAttachmentNdx]);
5006
5007                                         if (depthStencilAttachment)
5008                                                 definedAttachments.insert(*depthStencilAttachment);
5009
5010                                         {
5011                                                 std::vector<AttachmentReference>        inputAttachmentReferences;
5012                                                 std::vector<AttachmentReference>        colorAttachmentReferences;
5013                                                 AttachmentReference                                     depthStencilAttachmentReference (VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL);
5014
5015                                                 for (size_t colorAttachmentNdx = 0; colorAttachmentNdx < subpassColorAttachments.size(); colorAttachmentNdx++)
5016                                                 {
5017                                                         const deUint32          colorAttachmentIndex    = subpassColorAttachments[colorAttachmentNdx];
5018                                                         // \todo [mika 2016-08-25] Check if attachment is not used as input attachment and use other image layouts
5019                                                         const VkImageLayout     subpassLayout                   = VK_IMAGE_LAYOUT_GENERAL;
5020
5021                                                         if (lastUseOfAttachment[colorAttachmentIndex])
5022                                                         {
5023                                                                 const bool byRegion = rng.getBool();
5024
5025                                                                 deps.push_back(SubpassDependency(*lastUseOfAttachment[colorAttachmentIndex], subpassIndex,
5026                                                                                                                                  VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5027                                                                                                                                         | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5028                                                                                                                                         | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5029                                                                                                                                         | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5030
5031                                                                                                                                  VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5032                                                                                                                                         | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5033                                                                                                                                         | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5034                                                                                                                                         | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5035
5036                                                                                                                                  VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
5037                                                                                                                                  VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
5038
5039                                                                                                                                  byRegion ? (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT : 0u));
5040                                                         }
5041
5042                                                         lastUseOfAttachment[colorAttachmentIndex] = just(subpassIndex);
5043
5044                                                         colorAttachmentReferences.push_back(AttachmentReference((deUint32)subpassColorAttachments[colorAttachmentNdx], subpassLayout));
5045                                                 }
5046
5047                                                 for (size_t inputAttachmentNdx = 0; inputAttachmentNdx < subpassInputAttachments.size(); inputAttachmentNdx++)
5048                                                 {
5049                                                         const deUint32          inputAttachmentIndex    = subpassInputAttachments[inputAttachmentNdx];
5050                                                         // \todo [mika 2016-08-25] Check if attachment is not used as color attachment and use other image layouts
5051                                                         const VkImageLayout     subpassLayout                   = VK_IMAGE_LAYOUT_GENERAL;
5052
5053                                                         if(lastUseOfAttachment[inputAttachmentIndex])
5054                                                         {
5055                                                                 if(*lastUseOfAttachment[inputAttachmentIndex] == subpassIndex)
5056                                                                 {
5057                                                                         deps.push_back(SubpassDependency(subpassIndex, subpassIndex,
5058                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5059                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5060                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5061                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5062
5063                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5064                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5065                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5066                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5067
5068                                                                                                                                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
5069                                                                                                                                          VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5070
5071                                                                                                                                          VK_DEPENDENCY_BY_REGION_BIT));
5072                                                                 }
5073                                                                 else
5074                                                                 {
5075                                                                         const bool byRegion = rng.getBool();
5076
5077                                                                         deps.push_back(SubpassDependency(*lastUseOfAttachment[inputAttachmentIndex], subpassIndex,
5078                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5079                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5080                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5081                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5082
5083                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5084                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5085                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5086                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5087
5088                                                                                                                                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
5089                                                                                                                                          VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5090
5091                                                                                                                                          byRegion ? (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT : 0u));
5092                                                                 }
5093
5094                                                                 lastUseOfAttachment[inputAttachmentIndex] = just(subpassIndex);
5095
5096                                                                 inputAttachmentReferences.push_back(AttachmentReference((deUint32)subpassInputAttachments[inputAttachmentNdx], subpassLayout));
5097                                                         }
5098                                                 }
5099
5100                                                 if (depthStencilAttachment)
5101                                                 {
5102                                                         // \todo [mika 2016-08-25] Check if attachment is not used as input attachment and use other image layouts
5103                                                         if (lastUseOfAttachment[*depthStencilAttachment])
5104                                                         {
5105                                                                 if(*lastUseOfAttachment[*depthStencilAttachment] == subpassIndex)
5106                                                                 {
5107                                                                         deps.push_back(SubpassDependency(subpassIndex, subpassIndex,
5108                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5109                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5110                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5111                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5112
5113                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5114                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5115                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5116                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5117
5118                                                                                                                                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
5119                                                                                                                                          VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5120
5121                                                                                                                                          VK_DEPENDENCY_BY_REGION_BIT));
5122                                                                 }
5123                                                                 else
5124                                                                 {
5125                                                                         const bool byRegion = rng.getBool();
5126
5127                                                                         deps.push_back(SubpassDependency(*lastUseOfAttachment[*depthStencilAttachment], subpassIndex,
5128                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5129                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5130                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5131                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5132
5133                                                                                                                                          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5134                                                                                                                                                 | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5135                                                                                                                                                 | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5136                                                                                                                                                 | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5137
5138                                                                                                                                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
5139                                                                                                                                          VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5140
5141                                                                                                                                          byRegion ? (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT : 0u));
5142                                                                 }
5143                                                         }
5144
5145                                                         lastUseOfAttachment[*depthStencilAttachment] = just(subpassIndex);
5146                                                         depthStencilAttachmentReference = AttachmentReference(*depthStencilAttachment, VK_IMAGE_LAYOUT_GENERAL);
5147                                                 }
5148                                                 else
5149                                                         depthStencilAttachmentReference = AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL);
5150
5151                                                 vector<deUint32>        preserveAttachments;
5152                                                 for (deUint32 attachmentIndex = 0; attachmentIndex < (deUint32)attachments.size(); attachmentIndex++)
5153                                                 {
5154                                                         if (lastUseOfAttachment[attachmentIndex] && (*lastUseOfAttachment[attachmentIndex]) != subpassIndex)
5155                                                                 preserveAttachments.push_back(attachmentIndex);
5156                                                 }
5157
5158                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5159                                                                                                 inputAttachmentReferences,
5160                                                                                                 colorAttachmentReferences,
5161                                                                                                 vector<AttachmentReference>(),
5162                                                                                                 depthStencilAttachmentReference,
5163                                                                                                 preserveAttachments));
5164                                         }
5165                                 }
5166                                 {
5167                                         const TestConfig::RenderTypes                   render                  = rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
5168                                         const TestConfig::CommandBufferTypes    commandBuffer   = rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
5169                                         const TestConfig::ImageMemory                   imageMemory             = rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
5170
5171                                         const string                                                    testCaseName    = de::toString(testCaseNdx);
5172                                         const UVec2                                                             targetSize              = rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
5173                                         const UVec2                                                             renderPos               = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
5174                                         const UVec2                                                             renderSize              = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
5175
5176                                         const RenderPass                                                renderPass              (attachments, subpasses, deps);
5177
5178                                         addFunctionCaseWithPrograms<TestConfig>(allocationTypeGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, TestConfig(renderPass, render, commandBuffer, imageMemory, targetSize, renderPos, renderSize, 80329, allocationKind));
5179                                 }
5180                         }
5181                         else
5182                         {
5183                                 const deUint32          attachmentCount = rng.choose<deUint32>(DE_ARRAY_BEGIN(attachmentCounts), DE_ARRAY_END(attachmentCounts));
5184                                 vector<Attachment>      attachments;
5185                                 vector<Subpass>         subpasses;
5186
5187                                 for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount; attachmentNdx++)
5188                                 {
5189                                         const VkSampleCountFlagBits     sampleCount             = VK_SAMPLE_COUNT_1_BIT;
5190                                         const VkFormat                          format                  = rng.choose<VkFormat>(DE_ARRAY_BEGIN(s_coreColorFormats), DE_ARRAY_END(s_coreColorFormats));
5191                                         const VkAttachmentLoadOp        loadOp                  = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5192                                         const VkAttachmentStoreOp       storeOp                 = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5193
5194                                         const VkImageLayout                     initialLayout   = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
5195                                         const VkImageLayout                     finalizeLayout  = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
5196
5197                                         const VkAttachmentLoadOp        stencilLoadOp   = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
5198                                         const VkAttachmentStoreOp       stencilStoreOp  = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
5199
5200                                         attachments.push_back(Attachment(format, sampleCount, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalizeLayout));
5201                                 }
5202
5203                                 if (allocationType == ALLOCATIONTYPE_GROW)
5204                                 {
5205                                         for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
5206                                         {
5207                                                 vector<AttachmentReference>     colorAttachmentReferences;
5208
5209                                                 for (size_t attachmentNdx = 0; attachmentNdx < subpassNdx + 1; attachmentNdx++)
5210                                                 {
5211                                                         const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
5212
5213                                                         colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
5214                                                 }
5215
5216                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5217                                                                                                 vector<AttachmentReference>(),
5218                                                                                                 colorAttachmentReferences,
5219                                                                                                 vector<AttachmentReference>(),
5220                                                                                                 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5221                                                                                                 vector<deUint32>()));
5222                                         }
5223                                 }
5224                                 else if (allocationType == ALLOCATIONTYPE_SHRINK)
5225                                 {
5226                                         for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
5227                                         {
5228                                                 vector<AttachmentReference>     colorAttachmentReferences;
5229
5230                                                 for (size_t attachmentNdx = 0; attachmentNdx < (attachmentCount - subpassNdx); attachmentNdx++)
5231                                                 {
5232                                                         const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
5233
5234                                                         colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
5235                                                 }
5236
5237                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5238                                                                                                         vector<AttachmentReference>(),
5239                                                                                                         colorAttachmentReferences,
5240                                                                                                         vector<AttachmentReference>(),
5241                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5242                                                                                                         vector<deUint32>()));
5243                                         }
5244                                 }
5245                                 else if (allocationType == ALLOCATIONTYPE_ROLL)
5246                                 {
5247                                         for (size_t subpassNdx = 0; subpassNdx < attachmentCount / 2; subpassNdx++)
5248                                         {
5249                                                 vector<AttachmentReference>     colorAttachmentReferences;
5250
5251                                                 for (size_t attachmentNdx = 0; attachmentNdx < attachmentCount / 2; attachmentNdx++)
5252                                                 {
5253                                                         const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
5254
5255                                                         colorAttachmentReferences.push_back(AttachmentReference((deUint32)(subpassNdx + attachmentNdx), subpassLayout));
5256                                                 }
5257
5258                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5259                                                                                                         vector<AttachmentReference>(),
5260                                                                                                         colorAttachmentReferences,
5261                                                                                                         vector<AttachmentReference>(),
5262                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5263                                                                                                         vector<deUint32>()));
5264                                         }
5265                                 }
5266                                 else if (allocationType == ALLOCATIONTYPE_GROW_SHRINK)
5267                                 {
5268                                         for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
5269                                         {
5270                                                 vector<AttachmentReference>     colorAttachmentReferences;
5271
5272                                                 for (size_t attachmentNdx = 0; attachmentNdx < subpassNdx + 1; attachmentNdx++)
5273                                                 {
5274                                                         const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
5275
5276                                                         colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
5277                                                 }
5278
5279                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5280                                                                                                         vector<AttachmentReference>(),
5281                                                                                                         colorAttachmentReferences,
5282                                                                                                         vector<AttachmentReference>(),
5283                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5284                                                                                                         vector<deUint32>()));
5285                                         }
5286
5287                                         for (size_t subpassNdx = 0; subpassNdx < attachmentCount; subpassNdx++)
5288                                         {
5289                                                 vector<AttachmentReference>     colorAttachmentReferences;
5290
5291                                                 for (size_t attachmentNdx = 0; attachmentNdx < (attachmentCount - subpassNdx); attachmentNdx++)
5292                                                 {
5293                                                         const VkImageLayout subpassLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts));
5294
5295                                                         colorAttachmentReferences.push_back(AttachmentReference((deUint32)attachmentNdx, subpassLayout));
5296                                                 }
5297
5298                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5299                                                                                         vector<AttachmentReference>(),
5300                                                                                         colorAttachmentReferences,
5301                                                                                         vector<AttachmentReference>(),
5302                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5303                                                                                         vector<deUint32>()));
5304                                         }
5305                                 }
5306                                 else if (allocationType == ALLOCATIONTYPE_IO_CHAIN)
5307                                 {
5308                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5309                                                                                         vector<AttachmentReference>(),
5310                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts)))),
5311                                                                                         vector<AttachmentReference>(),
5312                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5313                                                                                         vector<deUint32>()));
5314
5315                                         for (size_t subpassNdx = 1; subpassNdx < attachmentCount; subpassNdx++)
5316                                         {
5317                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS, 0u,
5318                                                                                                 vector<AttachmentReference>(1, AttachmentReference((deUint32)(subpassNdx - 1), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)),
5319                                                                                                 vector<AttachmentReference>(1, AttachmentReference((deUint32)(subpassNdx), rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(subpassLayouts), DE_ARRAY_END(subpassLayouts)))),
5320                                                                                                 vector<AttachmentReference>(),
5321                                                                                                 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5322                                                                                                 vector<deUint32>()));
5323                                         }
5324                                 }
5325                                 else
5326                                         DE_FATAL("Unknown allocation type");
5327
5328                                 {
5329                                         const TestConfig::RenderTypes                   render                  = rng.choose<TestConfig::RenderTypes>(DE_ARRAY_BEGIN(renderCommands), DE_ARRAY_END(renderCommands));
5330                                         const TestConfig::CommandBufferTypes    commandBuffer   = rng.choose<TestConfig::CommandBufferTypes>(DE_ARRAY_BEGIN(commandBuffers), DE_ARRAY_END(commandBuffers));
5331                                         const TestConfig::ImageMemory                   imageMemory             = rng.choose<TestConfig::ImageMemory>(DE_ARRAY_BEGIN(imageMemories), DE_ARRAY_END(imageMemories));
5332
5333                                         const string                                                    testCaseName    = de::toString(testCaseNdx);
5334                                         const UVec2                                                             targetSize              = rng.choose<UVec2>(DE_ARRAY_BEGIN(targetSizes), DE_ARRAY_END(targetSizes));
5335                                         const UVec2                                                             renderPos               = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderPositions), DE_ARRAY_END(renderPositions));
5336                                         const UVec2                                                             renderSize              = rng.choose<UVec2>(DE_ARRAY_BEGIN(renderSizes), DE_ARRAY_END(renderSizes));
5337
5338                                         vector<SubpassDependency>                               deps;
5339
5340                                         for (size_t subpassNdx = 0; subpassNdx < subpasses.size() - 1; subpassNdx++)
5341                                         {
5342                                                 const bool byRegion                             = rng.getBool();
5343                                                 deps.push_back(SubpassDependency((deUint32)subpassNdx, (deUint32)subpassNdx + 1,
5344                                                                                                                  VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5345                                                                                                                         | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5346                                                                                                                         | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5347                                                                                                                         | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5348
5349                                                                                                                  VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
5350                                                                                                                         | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
5351                                                                                                                         | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
5352                                                                                                                         | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
5353
5354                                                                                                                  VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
5355                                                                                                                  VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
5356
5357                                                                                                                  byRegion ? (VkDependencyFlags)VK_DEPENDENCY_BY_REGION_BIT : 0u));
5358                                         }
5359
5360                                         const RenderPass                                        renderPass              (attachments, subpasses, deps);
5361
5362                                         addFunctionCaseWithPrograms<TestConfig>(allocationTypeGroup.get(), testCaseName.c_str(), testCaseName.c_str(), createTestShaders, renderPassTest, TestConfig(renderPass, render, commandBuffer, imageMemory, targetSize, renderPos, renderSize, 80329, allocationKind));
5363                                 }
5364                         }
5365                 }
5366                 group->addChild(allocationTypeGroup.release());
5367         }
5368 }
5369
5370 void addSimpleTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
5371 {
5372         const UVec2     targetSize      (64, 64);
5373         const UVec2     renderPos       (0, 0);
5374         const UVec2     renderSize      (64, 64);
5375
5376         // color
5377         {
5378                 const RenderPass        renderPass      (vector<Attachment>(1, Attachment(VK_FORMAT_R8G8B8A8_UNORM,
5379                                                                                                                                                   VK_SAMPLE_COUNT_1_BIT,
5380                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_CLEAR,
5381                                                                                                                                                   VK_ATTACHMENT_STORE_OP_STORE,
5382                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5383                                                                                                                                                   VK_ATTACHMENT_STORE_OP_DONT_CARE,
5384                                                                                                                                                   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5385                                                                                                                                                   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5386                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5387                                                                                                                                         0u,
5388                                                                                                                                         vector<AttachmentReference>(),
5389                                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5390                                                                                                                                         vector<AttachmentReference>(),
5391                                                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5392                                                                                                                                         vector<deUint32>())),
5393                                                                                  vector<SubpassDependency>());
5394
5395                 addFunctionCaseWithPrograms<TestConfig>(group, "color", "Single color attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5396         }
5397
5398         // depth
5399         {
5400                 const RenderPass        renderPass      (vector<Attachment>(1, Attachment(VK_FORMAT_X8_D24_UNORM_PACK32,
5401                                                                                                                                                   VK_SAMPLE_COUNT_1_BIT,
5402                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_CLEAR,
5403                                                                                                                                                   VK_ATTACHMENT_STORE_OP_STORE,
5404                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5405                                                                                                                                                   VK_ATTACHMENT_STORE_OP_DONT_CARE,
5406                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5407                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
5408                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5409                                                                                                                                         0u,
5410                                                                                                                                         vector<AttachmentReference>(),
5411                                                                                                                                         vector<AttachmentReference>(),
5412                                                                                                                                         vector<AttachmentReference>(),
5413                                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5414                                                                                                                                         vector<deUint32>())),
5415                                                                                  vector<SubpassDependency>());
5416
5417                 addFunctionCaseWithPrograms<TestConfig>(group, "depth", "Single depth attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5418         }
5419
5420         // stencil
5421         {
5422                 const RenderPass        renderPass      (vector<Attachment>(1, Attachment(VK_FORMAT_S8_UINT,
5423                                                                                                                                                   VK_SAMPLE_COUNT_1_BIT,
5424                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5425                                                                                                                                                   VK_ATTACHMENT_STORE_OP_DONT_CARE,
5426                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_CLEAR,
5427                                                                                                                                                   VK_ATTACHMENT_STORE_OP_STORE,
5428                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5429                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
5430                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5431                                                                                                                                         0u,
5432                                                                                                                                         vector<AttachmentReference>(),
5433                                                                                                                                         vector<AttachmentReference>(),
5434                                                                                                                                         vector<AttachmentReference>(),
5435                                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5436                                                                                                                                         vector<deUint32>())),
5437                                                                                  vector<SubpassDependency>());
5438
5439                 addFunctionCaseWithPrograms<TestConfig>(group, "stencil", "Single stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5440         }
5441
5442         // depth_stencil
5443         {
5444                 const RenderPass        renderPass      (vector<Attachment>(1, Attachment(VK_FORMAT_D24_UNORM_S8_UINT,
5445                                                                                                                                                   VK_SAMPLE_COUNT_1_BIT,
5446                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_CLEAR,
5447                                                                                                                                                   VK_ATTACHMENT_STORE_OP_STORE,
5448                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_CLEAR,
5449                                                                                                                                                   VK_ATTACHMENT_STORE_OP_STORE,
5450                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5451                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
5452                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5453                                                                                                                                         0u,
5454                                                                                                                                         vector<AttachmentReference>(),
5455                                                                                                                                         vector<AttachmentReference>(),
5456                                                                                                                                         vector<AttachmentReference>(),
5457                                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5458                                                                                                                                         vector<deUint32>())),
5459                                                                                  vector<SubpassDependency>());
5460
5461                 addFunctionCaseWithPrograms<TestConfig>(group, "depth_stencil", "Single depth stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5462         }
5463
5464         // color_depth
5465         {
5466                 const Attachment        attachments[] =
5467                 {
5468                         Attachment(VK_FORMAT_R8G8B8A8_UNORM,
5469                                            VK_SAMPLE_COUNT_1_BIT,
5470                                            VK_ATTACHMENT_LOAD_OP_CLEAR,
5471                                            VK_ATTACHMENT_STORE_OP_STORE,
5472                                            VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5473                                            VK_ATTACHMENT_STORE_OP_DONT_CARE,
5474                                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5475                                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
5476                         Attachment(VK_FORMAT_X8_D24_UNORM_PACK32,
5477                                            VK_SAMPLE_COUNT_1_BIT,
5478                                            VK_ATTACHMENT_LOAD_OP_CLEAR,
5479                                            VK_ATTACHMENT_STORE_OP_STORE,
5480                                            VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5481                                            VK_ATTACHMENT_STORE_OP_DONT_CARE,
5482                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5483                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5484                 };
5485
5486                 const RenderPass        renderPass      (vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
5487                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5488                                                                                                                                         0u,
5489                                                                                                                                         vector<AttachmentReference>(),
5490                                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5491                                                                                                                                         vector<AttachmentReference>(),
5492                                                                                                                                         AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5493                                                                                                                                         vector<deUint32>())),
5494                                                                                  vector<SubpassDependency>());
5495
5496                 addFunctionCaseWithPrograms<TestConfig>(group, "color_depth", "Color and depth attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5497         }
5498
5499         // color_stencil
5500         {
5501                 const Attachment        attachments[] =
5502                 {
5503                         Attachment(VK_FORMAT_R8G8B8A8_UNORM,
5504                                            VK_SAMPLE_COUNT_1_BIT,
5505                                            VK_ATTACHMENT_LOAD_OP_CLEAR,
5506                                            VK_ATTACHMENT_STORE_OP_STORE,
5507                                            VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5508                                            VK_ATTACHMENT_STORE_OP_DONT_CARE,
5509                                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5510                                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
5511                         Attachment(VK_FORMAT_S8_UINT,
5512                                            VK_SAMPLE_COUNT_1_BIT,
5513                                            VK_ATTACHMENT_LOAD_OP_CLEAR,
5514                                            VK_ATTACHMENT_STORE_OP_STORE,
5515                                            VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5516                                            VK_ATTACHMENT_STORE_OP_DONT_CARE,
5517                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5518                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5519                 };
5520
5521                 const RenderPass        renderPass      (vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
5522                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5523                                                                                                                                         0u,
5524                                                                                                                                         vector<AttachmentReference>(),
5525                                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5526                                                                                                                                         vector<AttachmentReference>(),
5527                                                                                                                                         AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5528                                                                                                                                         vector<deUint32>())),
5529                                                                                  vector<SubpassDependency>());
5530
5531
5532                 addFunctionCaseWithPrograms<TestConfig>(group, "color_stencil", "Color and stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5533         }
5534
5535         // color_depth_stencil
5536         {
5537                 const Attachment        attachments[] =
5538                 {
5539                         Attachment(VK_FORMAT_R8G8B8A8_UNORM,
5540                                            VK_SAMPLE_COUNT_1_BIT,
5541                                            VK_ATTACHMENT_LOAD_OP_CLEAR,
5542                                            VK_ATTACHMENT_STORE_OP_STORE,
5543                                            VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5544                                            VK_ATTACHMENT_STORE_OP_DONT_CARE,
5545                                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5546                                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL),
5547                         Attachment(VK_FORMAT_D24_UNORM_S8_UINT,
5548                                            VK_SAMPLE_COUNT_1_BIT,
5549                                            VK_ATTACHMENT_LOAD_OP_CLEAR,
5550                                            VK_ATTACHMENT_STORE_OP_STORE,
5551                                            VK_ATTACHMENT_LOAD_OP_CLEAR,
5552                                            VK_ATTACHMENT_STORE_OP_STORE,
5553                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5554                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5555                 };
5556
5557                 const RenderPass        renderPass      (vector<Attachment>(DE_ARRAY_BEGIN(attachments), DE_ARRAY_END(attachments)),
5558                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5559                                                                                                                                         0u,
5560                                                                                                                                         vector<AttachmentReference>(),
5561                                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5562                                                                                                                                         vector<AttachmentReference>(),
5563                                                                                                                                         AttachmentReference(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5564                                                                                                                                         vector<deUint32>())),
5565                                                                                  vector<SubpassDependency>());
5566
5567                 addFunctionCaseWithPrograms<TestConfig>(group, "color_depth_stencil", "Color, depth and stencil attachment case.", createTestShaders, renderPassTest, TestConfig(renderPass, TestConfig::RENDERTYPES_DRAW, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5568         }
5569 }
5570
5571 std::string formatToName (VkFormat format)
5572 {
5573         const std::string       formatStr       = de::toString(format);
5574         const std::string       prefix          = "VK_FORMAT_";
5575
5576         DE_ASSERT(formatStr.substr(0, prefix.length()) == prefix);
5577
5578         return de::toLower(formatStr.substr(prefix.length()));
5579 }
5580
5581 void addFormatTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
5582 {
5583         tcu::TestContext&       testCtx         = group->getTestContext();
5584
5585         const UVec2                     targetSize      (64, 64);
5586         const UVec2                     renderPos       (0, 0);
5587         const UVec2                     renderSize      (64, 64);
5588
5589         const struct
5590         {
5591                 const char* const                       str;
5592                 const VkAttachmentStoreOp       op;
5593         } storeOps[] =
5594         {
5595                 { "store",              VK_ATTACHMENT_STORE_OP_STORE            },
5596                 { "dont_care",  VK_ATTACHMENT_STORE_OP_DONT_CARE        }
5597         };
5598
5599         const struct
5600         {
5601                 const char* const                       str;
5602                 const VkAttachmentLoadOp        op;
5603         } loadOps[] =
5604         {
5605                 { "clear",              VK_ATTACHMENT_LOAD_OP_CLEAR             },
5606                 { "load",               VK_ATTACHMENT_LOAD_OP_LOAD              },
5607                 { "dont_care",  VK_ATTACHMENT_LOAD_OP_DONT_CARE }
5608         };
5609
5610         const struct
5611         {
5612                  const char* const                              str;
5613                  const TestConfig::RenderTypes  types;
5614         } renderTypes[] =
5615         {
5616                 { "clear",              TestConfig::RENDERTYPES_CLEAR                                                           },
5617                 { "draw",               TestConfig::RENDERTYPES_DRAW                                                            },
5618                 { "clear_draw", TestConfig::RENDERTYPES_CLEAR|TestConfig::RENDERTYPES_DRAW      }
5619         };
5620
5621         // Color formats
5622         for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_coreColorFormats); formatNdx++)
5623         {
5624                 const VkFormat                                  format          = s_coreColorFormats[formatNdx];
5625                 de::MovePtr<tcu::TestCaseGroup> formatGroup     (new tcu::TestCaseGroup(testCtx, formatToName(format).c_str(), de::toString(format).c_str()));
5626
5627                 for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
5628                 {
5629                         const VkAttachmentLoadOp                loadOp  = loadOps[loadOpNdx].op;
5630                         de::MovePtr<tcu::TestCaseGroup> loadOpGroup     (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
5631
5632                         for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
5633                         {
5634                                 const RenderPass        renderPass      (vector<Attachment>(1, Attachment(format,
5635                                                                                                                                                                   VK_SAMPLE_COUNT_1_BIT,
5636                                                                                                                                                                   loadOp,
5637                                                                                                                                                                   VK_ATTACHMENT_STORE_OP_STORE,
5638                                                                                                                                                                   VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5639                                                                                                                                                                   VK_ATTACHMENT_STORE_OP_DONT_CARE,
5640                                                                                                                                                                   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5641                                                                                                                                                                   VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5642                                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5643                                                                                                                                                         0u,
5644                                                                                                                                                         vector<AttachmentReference>(),
5645                                                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5646                                                                                                                                                         vector<AttachmentReference>(),
5647                                                                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5648                                                                                                                                                         vector<deUint32>())),
5649                                                                                                  vector<SubpassDependency>());
5650
5651                                 addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), renderTypes[renderTypeNdx].str, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5652                         }
5653
5654                         formatGroup->addChild(loadOpGroup.release());
5655                 }
5656
5657                 {
5658                         de::MovePtr<tcu::TestCaseGroup> inputGroup (new tcu::TestCaseGroup(testCtx, "input", "Test attachment format as input"));
5659
5660                         for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
5661                         {
5662                                 const VkAttachmentLoadOp                loadOp          = loadOps[loadOpNdx].op;
5663                                 de::MovePtr<tcu::TestCaseGroup> loadOpGroup     (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
5664
5665                                 for (size_t storeOpNdx = 0; storeOpNdx < DE_LENGTH_OF_ARRAY(storeOps); storeOpNdx++)
5666                                 {
5667                                         const VkAttachmentStoreOp               storeOp                 = storeOps[storeOpNdx].op;
5668                                         de::MovePtr<tcu::TestCaseGroup> storeOpGroup    (new tcu::TestCaseGroup(testCtx, storeOps[storeOpNdx].str, storeOps[storeOpNdx].str));
5669
5670                                         for (size_t useInputAspectNdx = 0; useInputAspectNdx < 2; useInputAspectNdx++)
5671                                         {
5672                                                 const bool useInputAspect = useInputAspectNdx != 0;
5673
5674                                                 for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
5675                                                 {
5676                                                         {
5677                                                                 vector<Attachment>                                                      attachments;
5678                                                                 vector<Subpass>                                                         subpasses;
5679                                                                 vector<SubpassDependency>                                       deps;
5680                                                                 vector<VkInputAttachmentAspectReference>        inputAspects;
5681
5682                                                                 attachments.push_back(Attachment(format,
5683                                                                                                                                  VK_SAMPLE_COUNT_1_BIT,
5684                                                                                                                                  loadOp,
5685                                                                                                                                  storeOp,
5686                                                                                                                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5687                                                                                                                                  VK_ATTACHMENT_STORE_OP_DONT_CARE,
5688                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5689                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
5690
5691                                                                 attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
5692                                                                                                                                  VK_SAMPLE_COUNT_1_BIT,
5693                                                                                                                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5694                                                                                                                                  VK_ATTACHMENT_STORE_OP_STORE,
5695                                                                                                                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5696                                                                                                                                  VK_ATTACHMENT_STORE_OP_DONT_CARE,
5697                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5698                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
5699
5700                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5701                                                                                                                         0u,
5702                                                                                                                         vector<AttachmentReference>(),
5703                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5704                                                                                                                         vector<AttachmentReference>(),
5705                                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5706                                                                                                                         vector<deUint32>()));
5707                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5708                                                                                                                         0u,
5709                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)),
5710                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5711                                                                                                                         vector<AttachmentReference>(),
5712                                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5713                                                                                                                         vector<deUint32>()));
5714
5715                                                                 deps.push_back(SubpassDependency(0, 1,
5716
5717                                                                                                                                 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
5718                                                                                                                                 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
5719
5720                                                                                                                                 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
5721                                                                                                                                 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5722                                                                                                                                 vk::VK_DEPENDENCY_BY_REGION_BIT));
5723
5724                                                                 if (useInputAspect)
5725                                                                 {
5726                                                                         const VkInputAttachmentAspectReference inputAspect =
5727                                                                         {
5728                                                                                 0u,
5729                                                                                 0u,
5730                                                                                 VK_IMAGE_ASPECT_COLOR_BIT
5731                                                                         };
5732
5733                                                                         inputAspects.push_back(inputAspect);
5734                                                                 }
5735
5736                                                                 {
5737                                                                         const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
5738
5739                                                                         addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : ""), renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
5740                                                                 }
5741                                                         }
5742                                                         {
5743                                                                 vector<Attachment>                                                      attachments;
5744                                                                 vector<Subpass>                                                         subpasses;
5745                                                                 vector<SubpassDependency>                                       deps;
5746                                                                 vector<VkInputAttachmentAspectReference>        inputAspects;
5747
5748                                                                 attachments.push_back(Attachment(format,
5749                                                                                                                                  VK_SAMPLE_COUNT_1_BIT,
5750                                                                                                                                  loadOp,
5751                                                                                                                                  storeOp,
5752                                                                                                                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5753                                                                                                                                  VK_ATTACHMENT_STORE_OP_DONT_CARE,
5754                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5755                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
5756
5757                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5758                                                                                                                         0u,
5759                                                                                                                         vector<AttachmentReference>(),
5760                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5761                                                                                                                         vector<AttachmentReference>(),
5762                                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5763                                                                                                                         vector<deUint32>()));
5764                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5765                                                                                                                         0u,
5766                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL)),
5767                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL)),
5768                                                                                                                         vector<AttachmentReference>(),
5769                                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5770                                                                                                                         vector<deUint32>()));
5771
5772                                                                 deps.push_back(SubpassDependency(0, 1,
5773                                                                                                                                 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
5774                                                                                                                                 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
5775
5776                                                                                                                                 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
5777                                                                                                                                 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5778                                                                                                                                 vk::VK_DEPENDENCY_BY_REGION_BIT));
5779
5780                                                                 if (useInputAspect)
5781                                                                 {
5782                                                                         const VkInputAttachmentAspectReference inputAspect =
5783                                                                         {
5784                                                                                 0u,
5785                                                                                 0u,
5786                                                                                 VK_IMAGE_ASPECT_COLOR_BIT
5787                                                                         };
5788
5789                                                                         inputAspects.push_back(inputAspect);
5790                                                                 }
5791
5792                                                                 {
5793                                                                         const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
5794
5795                                                                         addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : ""), string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
5796                                                                 }
5797                                                         }
5798                                                 }
5799                                         }
5800
5801                                         loadOpGroup->addChild(storeOpGroup.release());
5802                                 }
5803
5804                                 inputGroup->addChild(loadOpGroup.release());
5805                         }
5806
5807                         formatGroup->addChild(inputGroup.release());
5808                 }
5809
5810                 group->addChild(formatGroup.release());
5811         }
5812
5813         // Depth stencil formats
5814         for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_coreDepthStencilFormats); formatNdx++)
5815         {
5816                 const VkFormat                                  vkFormat                        = s_coreDepthStencilFormats[formatNdx];
5817                 const tcu::TextureFormat                format                          = mapVkFormat(vkFormat);
5818                 const bool                                              isStencilAttachment     = hasStencilComponent(format.order);
5819                 const bool                                              isDepthAttachment       = hasDepthComponent(format.order);
5820                 de::MovePtr<tcu::TestCaseGroup> formatGroup                     (new tcu::TestCaseGroup(testCtx, formatToName(vkFormat).c_str(), de::toString(vkFormat).c_str()));
5821
5822                 for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
5823                 {
5824                         const VkAttachmentLoadOp                loadOp  = loadOps[loadOpNdx].op;
5825                         de::MovePtr<tcu::TestCaseGroup> loadOpGroup     (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
5826
5827                         for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
5828                         {
5829                                 {
5830                                         const RenderPass                        renderPass                      (vector<Attachment>(1, Attachment(vkFormat,
5831                                                                                                                                                                           VK_SAMPLE_COUNT_1_BIT,
5832                                                                                                                                                                           isDepthAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5833                                                                                                                                                                           isDepthAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
5834                                                                                                                                                                           isStencilAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5835                                                                                                                                                                           isStencilAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
5836                                                                                                                                                                           VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5837                                                                                                                                                                           VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
5838                                                                                                          vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5839                                                                                                                                                                 0u,
5840                                                                                                                                                                 vector<AttachmentReference>(),
5841                                                                                                                                                                 vector<AttachmentReference>(),
5842                                                                                                                                                                 vector<AttachmentReference>(),
5843                                                                                                                                                                 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5844                                                                                                                                                                 vector<deUint32>())),
5845                                                                                                          vector<SubpassDependency>());
5846
5847                                         addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), renderTypes[renderTypeNdx].str, renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5848                                 }
5849
5850                                 if (isStencilAttachment && isDepthAttachment)
5851                                 {
5852                                         {
5853                                                 const RenderPass                        renderPass                      (vector<Attachment>(1, Attachment(vkFormat,
5854                                                                                                                                                                                                   VK_SAMPLE_COUNT_1_BIT,
5855                                                                                                                                                                                                   isDepthAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5856                                                                                                                                                                                                   isDepthAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
5857                                                                                                                                                                                                   isStencilAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5858                                                                                                                                                                                                   isStencilAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
5859                                                                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5860                                                                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
5861                                                                                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5862                                                                                                                                                                                                         0u,
5863                                                                                                                                                                                                         vector<AttachmentReference>(),
5864                                                                                                                                                                                                         vector<AttachmentReference>(),
5865                                                                                                                                                                                                         vector<AttachmentReference>(),
5866                                                                                                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL),
5867                                                                                                                                                                                                         vector<deUint32>())),
5868                                                                                                                                                  vector<SubpassDependency>());
5869
5870                                                 addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), string(renderTypes[renderTypeNdx].str) + "_depth_read_only", renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5871                                         }
5872
5873                                         {
5874                                                 const RenderPass                        renderPass                      (vector<Attachment>(1, Attachment(vkFormat,
5875                                                                                                                                                                                   VK_SAMPLE_COUNT_1_BIT,
5876                                                                                                                                                                                   isDepthAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5877                                                                                                                                                                                   isDepthAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
5878                                                                                                                                                                                   isStencilAttachment ? loadOp : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5879                                                                                                                                                                                   isStencilAttachment ? VK_ATTACHMENT_STORE_OP_STORE :VK_ATTACHMENT_STORE_OP_DONT_CARE,
5880                                                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5881                                                                                                                                                                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)),
5882                                                                                                                                                  vector<Subpass>(1, Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5883                                                                                                                                                                                                         0u,
5884                                                                                                                                                                                                         vector<AttachmentReference>(),
5885                                                                                                                                                                                                         vector<AttachmentReference>(),
5886                                                                                                                                                                                                         vector<AttachmentReference>(),
5887                                                                                                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL),
5888                                                                                                                                                                                                         vector<deUint32>())),
5889                                                                                                                                                  vector<SubpassDependency>());
5890
5891                                                 addFunctionCaseWithPrograms<TestConfig>(loadOpGroup.get(), string(renderTypes[renderTypeNdx].str) + "_stencil_read_only", renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 90239, allocationKind));
5892                                         }
5893                                 }
5894                         }
5895
5896                         formatGroup->addChild(loadOpGroup.release());
5897                 }
5898
5899                 {
5900                         de::MovePtr<tcu::TestCaseGroup> inputGroup (new tcu::TestCaseGroup(testCtx, "input", "Test attachment format as input"));
5901
5902                         for (size_t loadOpNdx = 0; loadOpNdx < DE_LENGTH_OF_ARRAY(loadOps); loadOpNdx++)
5903                         {
5904                                 const VkAttachmentLoadOp                loadOp          = loadOps[loadOpNdx].op;
5905                                 de::MovePtr<tcu::TestCaseGroup> loadOpGroup     (new tcu::TestCaseGroup(testCtx, loadOps[loadOpNdx].str, loadOps[loadOpNdx].str));
5906
5907                                 for (size_t storeOpNdx = 0; storeOpNdx < DE_LENGTH_OF_ARRAY(storeOps); storeOpNdx++)
5908                                 {
5909                                         const VkAttachmentStoreOp               storeOp                 = storeOps[storeOpNdx].op;
5910                                         de::MovePtr<tcu::TestCaseGroup> storeOpGroup    (new tcu::TestCaseGroup(testCtx, storeOps[storeOpNdx].str, storeOps[storeOpNdx].str));
5911
5912                                         for (size_t useInputAspectNdx = 0; useInputAspectNdx < 2; useInputAspectNdx++)
5913                                         {
5914                                                 const bool useInputAspect = useInputAspectNdx != 0;
5915
5916                                                 for (size_t renderTypeNdx = 0; renderTypeNdx < DE_LENGTH_OF_ARRAY(renderTypes); renderTypeNdx++)
5917                                                 {
5918                                                         {
5919                                                                 vector<Attachment>                                                      attachments;
5920                                                                 vector<Subpass>                                                         subpasses;
5921                                                                 vector<SubpassDependency>                                       deps;
5922                                                                 vector<VkInputAttachmentAspectReference>        inputAspects;
5923
5924                                                                 attachments.push_back(Attachment(vkFormat,
5925                                                                                                                                  VK_SAMPLE_COUNT_1_BIT,
5926                                                                                                                                  loadOp,
5927                                                                                                                                  storeOp,
5928                                                                                                                                  loadOp,
5929                                                                                                                                  storeOp,
5930                                                                                                                                  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
5931                                                                                                                                  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
5932
5933                                                                 attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
5934                                                                                                                                  VK_SAMPLE_COUNT_1_BIT,
5935                                                                                                                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5936                                                                                                                                  VK_ATTACHMENT_STORE_OP_STORE,
5937                                                                                                                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
5938                                                                                                                                  VK_ATTACHMENT_STORE_OP_DONT_CARE,
5939                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
5940                                                                                                                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
5941
5942                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5943                                                                                                                         0u,
5944                                                                                                                         vector<AttachmentReference>(),
5945                                                                                                                         vector<AttachmentReference>(),
5946                                                                                                                         vector<AttachmentReference>(),
5947                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
5948                                                                                                                         vector<deUint32>()));
5949                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
5950                                                                                                                         0u,
5951                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)),
5952                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
5953                                                                                                                         vector<AttachmentReference>(),
5954                                                                                                                         AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
5955                                                                                                                         vector<deUint32>()));
5956
5957                                                                 deps.push_back(SubpassDependency(0, 1,
5958                                                                                                                                 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
5959                                                                                                                                 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
5960
5961                                                                                                                                 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
5962                                                                                                                                 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5963                                                                                                                                 0u));
5964
5965                                                                 deps.push_back(SubpassDependency(1, 1,
5966                                                                                                                                 vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
5967                                                                                                                                 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
5968
5969                                                                                                                                 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
5970                                                                                                                                 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
5971                                                                                                                                 vk::VK_DEPENDENCY_BY_REGION_BIT));
5972
5973                                                                 if (useInputAspect)
5974                                                                 {
5975                                                                         const VkInputAttachmentAspectReference inputAspect =
5976                                                                         {
5977                                                                                 0u,
5978                                                                                 0u,
5979                                                                                 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
5980                                                                                         | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
5981                                                                         };
5982
5983                                                                         inputAspects.push_back(inputAspect);
5984                                                                 }
5985
5986                                                                 {
5987                                                                         const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
5988
5989                                                                         addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : ""), renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
5990                                                                 }
5991                                                         }
5992                                                         {
5993                                                                 vector<Attachment>                                                      attachments;
5994                                                                 vector<Subpass>                                                         subpasses;
5995                                                                 vector<SubpassDependency>                                       deps;
5996                                                                 vector<VkInputAttachmentAspectReference>        inputAspects;
5997
5998                                                                 attachments.push_back(Attachment(vkFormat,
5999                                                                                                                                  VK_SAMPLE_COUNT_1_BIT,
6000                                                                                                                                  loadOp,
6001                                                                                                                                  storeOp,
6002                                                                                                                                  VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6003                                                                                                                                  VK_ATTACHMENT_STORE_OP_DONT_CARE,
6004                                                                                                                                  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6005                                                                                                                                  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
6006
6007                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6008                                                                                                                         0u,
6009                                                                                                                         vector<AttachmentReference>(),
6010                                                                                                                         vector<AttachmentReference>(),
6011                                                                                                                         vector<AttachmentReference>(),
6012                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6013                                                                                                                         vector<deUint32>()));
6014                                                                 subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6015                                                                                                                         0u,
6016                                                                                                                         vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL)),
6017                                                                                                                         vector<AttachmentReference>(),
6018                                                                                                                         vector<AttachmentReference>(),
6019                                                                                                                         AttachmentReference(0, VK_IMAGE_LAYOUT_GENERAL),
6020                                                                                                                         vector<deUint32>()));
6021
6022                                                                 deps.push_back(SubpassDependency(0, 1,
6023                                                                                                                                 vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
6024                                                                                                                                 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6025
6026                                                                                                                                 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
6027                                                                                                                                 vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6028                                                                                                                                 vk::VK_DEPENDENCY_BY_REGION_BIT));
6029
6030
6031                                                                 if (useInputAspect)
6032                                                                 {
6033                                                                         const VkInputAttachmentAspectReference inputAspect =
6034                                                                         {
6035                                                                                 0u,
6036                                                                                 0u,
6037
6038                                                                                 (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
6039                                                                                         | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
6040                                                                         };
6041
6042                                                                         inputAspects.push_back(inputAspect);
6043                                                                 }
6044
6045                                                                 {
6046                                                                         const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
6047
6048                                                                         addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : ""), string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
6049                                                                 }
6050                                                         }
6051
6052                                                         if (isStencilAttachment && isDepthAttachment)
6053                                                         {
6054                                                                 // Depth read only
6055                                                                 {
6056                                                                         vector<Attachment>                                                      attachments;
6057                                                                         vector<Subpass>                                                         subpasses;
6058                                                                         vector<SubpassDependency>                                       deps;
6059                                                                         vector<VkInputAttachmentAspectReference>        inputAspects;
6060
6061                                                                         attachments.push_back(Attachment(vkFormat,
6062                                                                                                                                          VK_SAMPLE_COUNT_1_BIT,
6063                                                                                                                                          loadOp,
6064                                                                                                                                          storeOp,
6065                                                                                                                                          loadOp,
6066                                                                                                                                          storeOp,
6067                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6068                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
6069
6070                                                                         attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
6071                                                                                                                                          VK_SAMPLE_COUNT_1_BIT,
6072                                                                                                                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6073                                                                                                                                          VK_ATTACHMENT_STORE_OP_STORE,
6074                                                                                                                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6075                                                                                                                                          VK_ATTACHMENT_STORE_OP_DONT_CARE,
6076                                                                                                                                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6077                                                                                                                                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
6078
6079                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6080                                                                                                                                 0u,
6081                                                                                                                                 vector<AttachmentReference>(),
6082                                                                                                                                 vector<AttachmentReference>(),
6083                                                                                                                                 vector<AttachmentReference>(),
6084                                                                                                                                 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6085                                                                                                                                 vector<deUint32>()));
6086                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6087                                                                                                                                 0u,
6088                                                                                                                                 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)),
6089                                                                                                                                 vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6090                                                                                                                                 vector<AttachmentReference>(),
6091                                                                                                                                 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6092                                                                                                                                 vector<deUint32>()));
6093
6094                                                                         deps.push_back(SubpassDependency(0, 1,
6095                                                                                                                                         vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
6096                                                                                                                                         vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6097
6098                                                                                                                                         vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
6099                                                                                                                                         vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6100                                                                                                                                         0u));
6101
6102                                                                         if (useInputAspect)
6103                                                                         {
6104                                                                                 const VkInputAttachmentAspectReference inputAspect =
6105                                                                                 {
6106                                                                                         0u,
6107                                                                                         0u,
6108
6109                                                                                         (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
6110                                                                                                 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
6111                                                                                 };
6112
6113                                                                                 inputAspects.push_back(inputAspect);
6114                                                                         }
6115
6116                                                                         {
6117                                                                                 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
6118
6119                                                                                 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : "") + "_depth_read_only", renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
6120                                                                         }
6121                                                                 }
6122                                                                 {
6123                                                                         vector<Attachment>                                                      attachments;
6124                                                                         vector<Subpass>                                                         subpasses;
6125                                                                         vector<SubpassDependency>                                       deps;
6126                                                                         vector<VkInputAttachmentAspectReference>        inputAspects;
6127
6128                                                                         attachments.push_back(Attachment(vkFormat,
6129                                                                                                                                          VK_SAMPLE_COUNT_1_BIT,
6130                                                                                                                                          loadOp,
6131                                                                                                                                          storeOp,
6132                                                                                                                                          loadOp,
6133                                                                                                                                          storeOp,
6134                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6135                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
6136
6137                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6138                                                                                                                                 0u,
6139                                                                                                                                 vector<AttachmentReference>(),
6140                                                                                                                                 vector<AttachmentReference>(),
6141                                                                                                                                 vector<AttachmentReference>(),
6142                                                                                                                                 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6143                                                                                                                                 vector<deUint32>()));
6144                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6145                                                                                                                                 0u,
6146                                                                                                                                 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)),
6147                                                                                                                                 vector<AttachmentReference>(),
6148                                                                                                                                 vector<AttachmentReference>(),
6149                                                                                                                                 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL),
6150                                                                                                                                 vector<deUint32>()));
6151
6152                                                                         deps.push_back(SubpassDependency(0, 1,
6153                                                                                                                                         vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
6154                                                                                                                                         vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6155
6156                                                                                                                                         vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
6157                                                                                                                                         vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6158                                                                                                                                         vk::VK_DEPENDENCY_BY_REGION_BIT));
6159
6160                                                                         deps.push_back(SubpassDependency(1, 1,
6161                                                                                                                                         vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
6162                                                                                                                                         vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6163
6164                                                                                                                                         vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
6165                                                                                                                                         vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6166                                                                                                                                         vk::VK_DEPENDENCY_BY_REGION_BIT));
6167
6168
6169                                                                         if (useInputAspect)
6170                                                                         {
6171                                                                                 const VkInputAttachmentAspectReference inputAspect =
6172                                                                                 {
6173                                                                                         0u,
6174                                                                                         0u,
6175
6176                                                                                         (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
6177                                                                                                 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
6178                                                                                 };
6179
6180                                                                                 inputAspects.push_back(inputAspect);
6181                                                                         }
6182
6183                                                                         {
6184                                                                                 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
6185
6186                                                                                 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : "") + "_depth_read_only", string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
6187                                                                         }
6188                                                                 }
6189                                                                 // Stencil read only
6190                                                                 {
6191                                                                         vector<Attachment>                                                      attachments;
6192                                                                         vector<Subpass>                                                         subpasses;
6193                                                                         vector<SubpassDependency>                                       deps;
6194                                                                         vector<VkInputAttachmentAspectReference>        inputAspects;
6195
6196                                                                         attachments.push_back(Attachment(vkFormat,
6197                                                                                                                                          VK_SAMPLE_COUNT_1_BIT,
6198                                                                                                                                          loadOp,
6199                                                                                                                                          storeOp,
6200                                                                                                                                          loadOp,
6201                                                                                                                                          storeOp,
6202                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6203                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
6204
6205                                                                         attachments.push_back(Attachment(vk::VK_FORMAT_R8G8B8A8_UNORM,
6206                                                                                                                                          VK_SAMPLE_COUNT_1_BIT,
6207                                                                                                                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6208                                                                                                                                          VK_ATTACHMENT_STORE_OP_STORE,
6209                                                                                                                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
6210                                                                                                                                          VK_ATTACHMENT_STORE_OP_DONT_CARE,
6211                                                                                                                                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
6212                                                                                                                                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL));
6213
6214                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6215                                                                                                                                 0u,
6216                                                                                                                                 vector<AttachmentReference>(),
6217                                                                                                                                 vector<AttachmentReference>(),
6218                                                                                                                                 vector<AttachmentReference>(),
6219                                                                                                                                 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6220                                                                                                                                 vector<deUint32>()));
6221                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6222                                                                                                                                 0u,
6223                                                                                                                                 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)),
6224                                                                                                                                 vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
6225                                                                                                                                 vector<AttachmentReference>(),
6226                                                                                                                                 AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
6227                                                                                                                                 vector<deUint32>()));
6228
6229                                                                         deps.push_back(SubpassDependency(0, 1,
6230                                                                                                                                         vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
6231                                                                                                                                         vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6232
6233                                                                                                                                         vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
6234                                                                                                                                         vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6235                                                                                                                                         0u));
6236
6237                                                                         if (useInputAspect)
6238                                                                         {
6239                                                                                 const VkInputAttachmentAspectReference inputAspect =
6240                                                                                 {
6241                                                                                         0u,
6242                                                                                         0u,
6243
6244                                                                                         (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
6245                                                                                                 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
6246                                                                                 };
6247
6248                                                                                 inputAspects.push_back(inputAspect);
6249                                                                         }
6250
6251                                                                         {
6252                                                                                 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
6253
6254                                                                                 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), renderTypes[renderTypeNdx].str + string(useInputAspect ? "_use_input_aspect" : "") + "_stencil_read_only", renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
6255                                                                         }
6256                                                                 }
6257                                                                 {
6258                                                                         vector<Attachment>                                                      attachments;
6259                                                                         vector<Subpass>                                                         subpasses;
6260                                                                         vector<SubpassDependency>                                       deps;
6261                                                                         vector<VkInputAttachmentAspectReference>        inputAspects;
6262
6263                                                                         attachments.push_back(Attachment(vkFormat,
6264                                                                                                                                          VK_SAMPLE_COUNT_1_BIT,
6265                                                                                                                                          loadOp,
6266                                                                                                                                          storeOp,
6267                                                                                                                                          loadOp,
6268                                                                                                                                          storeOp,
6269                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
6270                                                                                                                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL));
6271
6272                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6273                                                                                                                                 0u,
6274                                                                                                                                 vector<AttachmentReference>(),
6275                                                                                                                                 vector<AttachmentReference>(),
6276                                                                                                                                 vector<AttachmentReference>(),
6277                                                                                                                                 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL),
6278                                                                                                                                 vector<deUint32>()));
6279                                                                         subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
6280                                                                                                                                 0u,
6281                                                                                                                                 vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)),
6282                                                                                                                                 vector<AttachmentReference>(),
6283                                                                                                                                 vector<AttachmentReference>(),
6284                                                                                                                                 AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL),
6285                                                                                                                                 vector<deUint32>()));
6286
6287                                                                         deps.push_back(SubpassDependency(0, 1,
6288                                                                                                                                         vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
6289                                                                                                                                         vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6290
6291                                                                                                                                         vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
6292                                                                                                                                         vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6293                                                                                                                                         vk::VK_DEPENDENCY_BY_REGION_BIT));
6294
6295                                                                         deps.push_back(SubpassDependency(1, 1,
6296                                                                                                                                         vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
6297                                                                                                                                         vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
6298
6299                                                                                                                                         vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
6300                                                                                                                                         vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
6301                                                                                                                                         vk::VK_DEPENDENCY_BY_REGION_BIT));
6302
6303
6304                                                                         if (useInputAspect)
6305                                                                         {
6306                                                                                 const VkInputAttachmentAspectReference inputAspect =
6307                                                                                 {
6308                                                                                         0u,
6309                                                                                         0u,
6310
6311                                                                                         (isDepthAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT : 0u)
6312                                                                                                 | (isStencilAttachment ? (VkImageAspectFlags)VK_IMAGE_ASPECT_STENCIL_BIT : 0u)
6313                                                                                 };
6314
6315                                                                                 inputAspects.push_back(inputAspect);
6316                                                                         }
6317
6318                                                                         {
6319                                                                                 const RenderPass renderPass (attachments, subpasses, deps, inputAspects);
6320
6321                                                                                 addFunctionCaseWithPrograms<TestConfig>(storeOpGroup.get(), string("self_dep_") + renderTypes[renderTypeNdx].str + (useInputAspect ? "_use_input_aspect" : "") + "_stencil_read_only", string("self_dep_") + renderTypes[renderTypeNdx].str, createTestShaders, renderPassTest, TestConfig(renderPass, renderTypes[renderTypeNdx].types, TestConfig::COMMANDBUFFERTYPES_INLINE, TestConfig::IMAGEMEMORY_STRICT, targetSize, renderPos, renderSize, 89246, allocationKind));
6322                                                                         }
6323                                                                 }
6324                                                         }
6325                                                 }
6326                                         }
6327
6328                                         loadOpGroup->addChild(storeOpGroup.release());
6329                                 }
6330
6331                                 inputGroup->addChild(loadOpGroup.release());
6332                         }
6333
6334                         formatGroup->addChild(inputGroup.release());
6335                 }
6336
6337                 group->addChild(formatGroup.release());
6338         }
6339 }
6340
6341 void addRenderPassTests (tcu::TestCaseGroup* group, AllocationKind allocationKind)
6342 {
6343         addTestGroup(group, "simple", "Simple basic render pass tests", addSimpleTests, allocationKind);
6344         addTestGroup(group, "formats", "Tests for different image formats.", addFormatTests, allocationKind);
6345         addTestGroup(group, "attachment", "Attachment format and count tests with load and store ops and image layouts", addAttachmentTests, allocationKind);
6346         addTestGroup(group, "attachment_allocation", "Attachment allocation tests", addAttachmentAllocationTests, allocationKind);
6347 }
6348
6349 de::MovePtr<tcu::TestCaseGroup> createSuballocationTests(tcu::TestContext& testCtx)
6350 {
6351         de::MovePtr<tcu::TestCaseGroup> suballocationTestsGroup(new tcu::TestCaseGroup(testCtx, "suballocation", "Suballocation RenderPass Tests"));
6352
6353         addRenderPassTests(suballocationTestsGroup.get(), ALLOCATION_KIND_SUBALLOCATED);
6354
6355         return suballocationTestsGroup;
6356 }
6357
6358 de::MovePtr<tcu::TestCaseGroup> createDedicatedAllocationTests(tcu::TestContext& testCtx)
6359 {
6360         de::MovePtr<tcu::TestCaseGroup> dedicatedAllocationTestsGroup(new tcu::TestCaseGroup(testCtx, "dedicated_allocation", "RenderPass Tests For Dedicated Allocation"));
6361
6362         addRenderPassTests(dedicatedAllocationTestsGroup.get(), ALLOCATION_KIND_DEDICATED);
6363
6364         return dedicatedAllocationTestsGroup;
6365 }
6366
6367 } // anonymous
6368
6369 tcu::TestCaseGroup* createRenderPassTests (tcu::TestContext& testCtx)
6370 {
6371         de::MovePtr<tcu::TestCaseGroup> renderpassTests                                 (new tcu::TestCaseGroup(testCtx, "renderpass", "RenderPass Tests"));
6372         de::MovePtr<tcu::TestCaseGroup> suballocationTestGroup                  = createSuballocationTests(testCtx);
6373         de::MovePtr<tcu::TestCaseGroup> dedicatedAllocationTestGroup    = createDedicatedAllocationTests(testCtx);
6374
6375         suballocationTestGroup->addChild(createRenderPassMultisampleTests(testCtx));
6376         suballocationTestGroup->addChild(createRenderPassMultisampleResolveTests(testCtx));
6377
6378         renderpassTests->addChild(suballocationTestGroup.release());
6379         renderpassTests->addChild(dedicatedAllocationTestGroup.release());
6380
6381         return renderpassTests.release();
6382 }
6383
6384 } // vkt