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

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2017 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 Tests for render passses with multisample attachments
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktRenderPassMultisampleTests.hpp"
  25
  26 #include "vktTestCaseUtil.hpp"
  27 #include "vktTestGroupUtil.hpp"
  28
  29 #include "vkDefs.hpp"
  30 #include "vkDeviceUtil.hpp"
  31 #include "vkImageUtil.hpp"
  32 #include "vkMemUtil.hpp"
  33 #include "vkPlatform.hpp"
  34 #include "vkPrograms.hpp"
  35 #include "vkQueryUtil.hpp"
  36 #include "vkRef.hpp"
  37 #include "vkRefUtil.hpp"
  38 #include "vkTypeUtil.hpp"
  39
  40 #include "tcuFloat.hpp"
  41 #include "tcuImageCompare.hpp"
  42 #include "tcuFormatUtil.hpp"
  43 #include "tcuMaybe.hpp"
  44 #include "tcuResultCollector.hpp"
  45 #include "tcuTestLog.hpp"
  46 #include "tcuTextureUtil.hpp"
  47 #include "tcuVectorUtil.hpp"
  48
  49 #include "deUniquePtr.hpp"
  50 #include "deSharedPtr.hpp"
  51
  52 using namespace vk;
  53
  54 using tcu::BVec4;
  55 using tcu::IVec2;
  56 using tcu::IVec4;
  57 using tcu::UVec2;
  58 using tcu::UVec4;
  59 using tcu::Vec2;
  60 using tcu::Vec4;
  61
  62 using tcu::Maybe;
  63 using tcu::just;
  64 using tcu::nothing;
  65
  66 using tcu::ConstPixelBufferAccess;
  67 using tcu::PixelBufferAccess;
  68
  69 using tcu::TestLog;
  70
  71 using std::pair;
  72 using std::string;
  73 using std::vector;
  74
  75 typedef de::SharedPtr<vk::Unique<VkImage> > VkImageSp;
  76 typedef de::SharedPtr<vk::Unique<VkImageView> > VkImageViewSp;
  77 typedef de::SharedPtr<vk::Unique<VkBuffer> > VkBufferSp;
  78 typedef de::SharedPtr<vk::Unique<VkPipeline> > VkPipelineSp;
  79
  80 namespace vkt
  81 {
  82 namespace
  83 {
  84 enum
  85 {
  86         MAX_COLOR_ATTACHMENT_COUNT = 4u
  87 };
  88
  89 template<typename T>
  90 de::SharedPtr<T> safeSharedPtr (T* ptr)
  91 {
  92         try
  93         {
  94                 return de::SharedPtr<T>(ptr);
  95         }
  96         catch (...)
  97         {
  98                 delete ptr;
  99                 throw;
 100         }
 101 }
 102
 103 VkImageAspectFlags getImageAspectFlags (VkFormat vkFormat)
 104 {
 105         const tcu::TextureFormat        format          (mapVkFormat(vkFormat));
 106         const bool                                      hasDepth        (tcu::hasDepthComponent(format.order));
 107         const bool                                      hasStencil      (tcu::hasStencilComponent(format.order));
 108
 109         if (hasDepth || hasStencil)
 110         {
 111                 return (hasDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : (VkImageAspectFlagBits)0u)
 112                                 | (hasStencil ? VK_IMAGE_ASPECT_STENCIL_BIT : (VkImageAspectFlagBits)0u);
 113         }
 114         else
 115                 return VK_IMAGE_ASPECT_COLOR_BIT;
 116 }
 117
 118 void bindBufferMemory (const DeviceInterface& vk, VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset)
 119 {
 120         VK_CHECK(vk.bindBufferMemory(device, buffer, mem, memOffset));
 121 }
 122
 123 void bindImageMemory (const DeviceInterface& vk, VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset)
 124 {
 125         VK_CHECK(vk.bindImageMemory(device, image, mem, memOffset));
 126 }
 127
 128 de::MovePtr<Allocation> createBufferMemory (const DeviceInterface&      vk,
 129                                                                                         VkDevice                                device,
 130                                                                                         Allocator&                              allocator,
 131                                                                                         VkBuffer                                buffer)
 132 {
 133         de::MovePtr<Allocation> allocation (allocator.allocate(getBufferMemoryRequirements(vk, device, buffer), MemoryRequirement::HostVisible));
 134         bindBufferMemory(vk, device, buffer, allocation->getMemory(), allocation->getOffset());
 135         return allocation;
 136 }
 137
 138 de::MovePtr<Allocation> createImageMemory (const DeviceInterface&       vk,
 139                                                                                    VkDevice                                     device,
 140                                                                                    Allocator&                           allocator,
 141                                                                                    VkImage                                      image)
 142 {
 143         de::MovePtr<Allocation> allocation (allocator.allocate(getImageMemoryRequirements(vk, device, image), MemoryRequirement::Any));
 144         bindImageMemory(vk, device, image, allocation->getMemory(), allocation->getOffset());
 145         return allocation;
 146 }
 147
 148 Move<VkImage> createImage (const DeviceInterface&       vk,
 149                                                    VkDevice                                     device,
 150                                                    VkImageCreateFlags           flags,
 151                                                    VkImageType                          imageType,
 152                                                    VkFormat                                     format,
 153                                                    VkExtent3D                           extent,
 154                                                    deUint32                                     mipLevels,
 155                                                    deUint32                                     arrayLayers,
 156                                                    VkSampleCountFlagBits        samples,
 157                                                    VkImageTiling                        tiling,
 158                                                    VkImageUsageFlags            usage,
 159                                                    VkSharingMode                        sharingMode,
 160                                                    deUint32                                     queueFamilyCount,
 161                                                    const deUint32*                      pQueueFamilyIndices,
 162                                                    VkImageLayout                        initialLayout)
 163 {
 164         const VkImageCreateInfo pCreateInfo =
 165         {
 166                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
 167                 DE_NULL,
 168                 flags,
 169                 imageType,
 170                 format,
 171                 extent,
 172                 mipLevels,
 173                 arrayLayers,
 174                 samples,
 175                 tiling,
 176                 usage,
 177                 sharingMode,
 178                 queueFamilyCount,
 179                 pQueueFamilyIndices,
 180                 initialLayout
 181         };
 182         return createImage(vk, device, &pCreateInfo);
 183 }
 184
 185 Move<VkImageView> createImageView (const DeviceInterface&       vk,
 186                                                                    VkDevice                                     device,
 187                                                                    VkImageViewCreateFlags       flags,
 188                                                                    VkImage                                      image,
 189                                                                    VkImageViewType                      viewType,
 190                                                                    VkFormat                                     format,
 191                                                                    VkComponentMapping           components,
 192                                                                    VkImageSubresourceRange      subresourceRange)
 193 {
 194         const VkImageViewCreateInfo pCreateInfo =
 195         {
 196                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 197                 DE_NULL,
 198                 flags,
 199                 image,
 200                 viewType,
 201                 format,
 202                 components,
 203                 subresourceRange,
 204         };
 205         return createImageView(vk, device, &pCreateInfo);
 206 }
 207
 208 Move<VkImage> createImage (const InstanceInterface&     vki,
 209                                                    VkPhysicalDevice                     physicalDevice,
 210                                                    const DeviceInterface&       vkd,
 211                                                    VkDevice                                     device,
 212                                                    VkFormat                                     vkFormat,
 213                                                    VkSampleCountFlagBits        sampleCountBit,
 214                                                    VkImageUsageFlags            usage,
 215                                                    deUint32                                     width,
 216                                                    deUint32                                     height)
 217 {
 218         try
 219         {
 220                 const tcu::TextureFormat                format                                  (mapVkFormat(vkFormat));
 221                 const VkImageType                               imageType                               (VK_IMAGE_TYPE_2D);
 222                 const VkImageTiling                             imageTiling                             (VK_IMAGE_TILING_OPTIMAL);
 223                 const VkFormatProperties                formatProperties                (getPhysicalDeviceFormatProperties(vki, physicalDevice, vkFormat));
 224                 const VkImageFormatProperties   imageFormatProperties   (getPhysicalDeviceImageFormatProperties(vki, physicalDevice, vkFormat, imageType, imageTiling, usage, 0u));
 225                 const VkExtent3D                                imageExtent                             =
 226                 {
 227                         width,
 228                         height,
 229                         1u
 230                 };
 231
 232                 if ((tcu::hasDepthComponent(format.order) || tcu::hasStencilComponent(format.order))
 233                         && (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0)
 234                         TCU_THROW(NotSupportedError, "Format can't be used as depth stencil attachment");
 235
 236                 if (!(tcu::hasDepthComponent(format.order) || tcu::hasStencilComponent(format.order))
 237                         && (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) == 0)
 238                         TCU_THROW(NotSupportedError, "Format can't be used as color attachment");
 239
 240                 if (imageFormatProperties.maxExtent.width < imageExtent.width
 241                         || imageFormatProperties.maxExtent.height < imageExtent.height
 242                         || ((imageFormatProperties.sampleCounts & sampleCountBit) == 0))
 243                 {
 244                         TCU_THROW(NotSupportedError, "Image type not supported");
 245                 }
 246
 247                 return createImage(vkd, device, 0u, imageType, vkFormat, imageExtent, 1u, 1u, sampleCountBit, imageTiling, usage, VK_SHARING_MODE_EXCLUSIVE, 0u, DE_NULL, VK_IMAGE_LAYOUT_UNDEFINED);
 248         }
 249         catch (const vk::Error& error)
 250         {
 251                 if (error.getError() == VK_ERROR_FORMAT_NOT_SUPPORTED)
 252                         TCU_THROW(NotSupportedError, "Image format not supported");
 253
 254                 throw;
 255         }
 256 }
 257
 258 Move<VkImageView> createImageAttachmentView (const DeviceInterface&     vkd,
 259                                                                                          VkDevice                               device,
 260                                                                                          VkImage                                image,
 261                                                                                          VkFormat                               format,
 262                                                                                          VkImageAspectFlags             aspect)
 263 {
 264         const VkImageSubresourceRange   range =
 265         {
 266                 aspect,
 267                 0u,
 268                 1u,
 269                 0u,
 270                 1u
 271         };
 272
 273         return createImageView(vkd, device, 0u, image, VK_IMAGE_VIEW_TYPE_2D, format, makeComponentMappingRGBA(), range);
 274 }
 275
 276 Move<VkImageView> createSrcPrimaryInputImageView (const DeviceInterface&        vkd,
 277                                                                                                   VkDevice                                      device,
 278                                                                                                   VkImage                                       image,
 279                                                                                                   VkFormat                                      format,
 280                                                                                                   VkImageAspectFlags            aspect)
 281 {
 282         const VkImageSubresourceRange   range =
 283         {
 284                 aspect == (VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT)
 285                         ? (VkImageAspectFlags)VK_IMAGE_ASPECT_DEPTH_BIT
 286                         : aspect,
 287                 0u,
 288                 1u,
 289                 0u,
 290                 1u
 291         };
 292
 293         return createImageView(vkd, device, 0u, image, VK_IMAGE_VIEW_TYPE_2D, format, makeComponentMappingRGBA(), range);
 294 }
 295
 296 Move<VkImageView> createSrcSecondaryInputImageView (const DeviceInterface&      vkd,
 297                                                                                                         VkDevice                                device,
 298                                                                                                         VkImage                                 image,
 299                                                                                                         VkFormat                                format,
 300                                                                                                         VkImageAspectFlags              aspect)
 301 {
 302         if (aspect == (VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT))
 303         {
 304                 const VkImageSubresourceRange   range =
 305                 {
 306                         VK_IMAGE_ASPECT_STENCIL_BIT,
 307                         0u,
 308                         1u,
 309                         0u,
 310                         1u
 311                 };
 312
 313                 return createImageView(vkd, device, 0u, image, VK_IMAGE_VIEW_TYPE_2D, format, makeComponentMappingRGBA(), range);
 314         }
 315         else
 316                 return Move<VkImageView>();
 317 }
 318
 319 VkDeviceSize getPixelSize (VkFormat vkFormat)
 320 {
 321         const tcu::TextureFormat        format  (mapVkFormat(vkFormat));
 322
 323         return format.getPixelSize();
 324 }
 325
 326 Move<VkBuffer> createBuffer (const DeviceInterface&             vkd,
 327                                                          VkDevice                                       device,
 328                                                          VkFormat                                       format,
 329                                                          deUint32                                       width,
 330                                                          deUint32                                       height)
 331 {
 332         const VkBufferUsageFlags        bufferUsage                     (VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 333         const VkDeviceSize                      pixelSize                       (getPixelSize(format));
 334         const VkBufferCreateInfo        createInfo                      =
 335         {
 336                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
 337                 DE_NULL,
 338                 0u,
 339
 340                 width * height * pixelSize,
 341                 bufferUsage,
 342
 343                 VK_SHARING_MODE_EXCLUSIVE,
 344                 0u,
 345                 DE_NULL
 346         };
 347         return createBuffer(vkd, device, &createInfo);
 348 }
 349
 350 VkSampleCountFlagBits sampleCountBitFromomSampleCount (deUint32 count)
 351 {
 352         switch (count)
 353         {
 354                 case 1:  return VK_SAMPLE_COUNT_1_BIT;
 355                 case 2:  return VK_SAMPLE_COUNT_2_BIT;
 356                 case 4:  return VK_SAMPLE_COUNT_4_BIT;
 357                 case 8:  return VK_SAMPLE_COUNT_8_BIT;
 358                 case 16: return VK_SAMPLE_COUNT_16_BIT;
 359                 case 32: return VK_SAMPLE_COUNT_32_BIT;
 360                 case 64: return VK_SAMPLE_COUNT_64_BIT;
 361
 362                 default:
 363                         DE_FATAL("Invalid sample count");
 364                         return (VkSampleCountFlagBits)(0x1u << count);
 365         }
 366 }
 367
 368 std::vector<VkImageSp> createMultisampleImages (const InstanceInterface&        vki,
 369                                                                                                 VkPhysicalDevice                        physicalDevice,
 370                                                                                                 const DeviceInterface&          vkd,
 371                                                                                                 VkDevice                                        device,
 372                                                                                                 VkFormat                                        format,
 373                                                                                                 deUint32                                        sampleCount,
 374                                                                                                 deUint32                                        width,
 375                                                                                                 deUint32                                        height)
 376 {
 377         std::vector<VkImageSp> images (sampleCount);
 378
 379         for (size_t imageNdx = 0; imageNdx < images.size(); imageNdx++)
 380                 images[imageNdx] = safeSharedPtr(new vk::Unique<VkImage>(createImage(vki, physicalDevice, vkd, device, format, sampleCountBitFromomSampleCount(sampleCount), VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, width, height)));
 381
 382         return images;
 383 }
 384
 385 std::vector<VkImageSp> createSingleSampleImages (const InstanceInterface&       vki,
 386                                                                                                  VkPhysicalDevice                       physicalDevice,
 387                                                                                                  const DeviceInterface&         vkd,
 388                                                                                                  VkDevice                                       device,
 389                                                                                                  VkFormat                                       format,
 390                                                                                                  deUint32                                       sampleCount,
 391                                                                                                  deUint32                                       width,
 392                                                                                                  deUint32                                       height)
 393 {
 394         std::vector<VkImageSp> images (sampleCount);
 395
 396         for (size_t imageNdx = 0; imageNdx < images.size(); imageNdx++)
 397                 images[imageNdx] = safeSharedPtr(new vk::Unique<VkImage>(createImage(vki, physicalDevice, vkd, device, format, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, width, height)));
 398
 399         return images;
 400 }
 401
 402 std::vector<de::SharedPtr<Allocation> > createImageMemory (const DeviceInterface&               vkd,
 403                                                                                                                    VkDevice                                             device,
 404                                                                                                                    Allocator&                                   allocator,
 405                                                                                                                    const std::vector<VkImageSp> images)
 406 {
 407         std::vector<de::SharedPtr<Allocation> > memory (images.size());
 408
 409         for (size_t memoryNdx = 0; memoryNdx < memory.size(); memoryNdx++)
 410                 memory[memoryNdx] = safeSharedPtr(createImageMemory(vkd, device, allocator, **images[memoryNdx]).release());
 411
 412         return memory;
 413 }
 414
 415 std::vector<VkImageViewSp> createImageAttachmentViews (const DeviceInterface&                   vkd,
 416                                                                                                            VkDevice                                                     device,
 417                                                                                                            const std::vector<VkImageSp>&        images,
 418                                                                                                            VkFormat                                                     format,
 419                                                                                                            VkImageAspectFlagBits                        aspect)
 420 {
 421         std::vector<VkImageViewSp> views (images.size());
 422
 423         for (size_t imageNdx = 0; imageNdx < images.size(); imageNdx++)
 424                 views[imageNdx] = safeSharedPtr(new vk::Unique<VkImageView>(createImageAttachmentView(vkd, device, **images[imageNdx], format, aspect)));
 425
 426         return views;
 427 }
 428
 429 std::vector<VkBufferSp> createBuffers (const DeviceInterface&   vkd,
 430                                                                            VkDevice                                     device,
 431                                                                            VkFormat                                     format,
 432                                                                            deUint32                                     sampleCount,
 433                                                                            deUint32                                     width,
 434                                                                            deUint32                                     height)
 435 {
 436         std::vector<VkBufferSp> buffers (sampleCount);
 437
 438         for (size_t bufferNdx = 0; bufferNdx < buffers.size(); bufferNdx++)
 439                 buffers[bufferNdx] = safeSharedPtr(new vk::Unique<VkBuffer>(createBuffer(vkd, device, format, width, height)));
 440
 441         return buffers;
 442 }
 443
 444 std::vector<de::SharedPtr<Allocation> > createBufferMemory (const DeviceInterface&                      vkd,
 445                                                                                                                         VkDevice                                                device,
 446                                                                                                                         Allocator&                                              allocator,
 447                                                                                                                         const std::vector<VkBufferSp>   buffers)
 448 {
 449         std::vector<de::SharedPtr<Allocation> > memory (buffers.size());
 450
 451         for (size_t memoryNdx = 0; memoryNdx < memory.size(); memoryNdx++)
 452                 memory[memoryNdx] = safeSharedPtr(createBufferMemory(vkd, device, allocator, **buffers[memoryNdx]).release());
 453
 454         return memory;
 455 }
 456
 457 Move<VkRenderPass> createRenderPass (const DeviceInterface&     vkd,
 458                                                                          VkDevice                               device,
 459                                                                          VkFormat                               srcFormat,
 460                                                                          VkFormat                               dstFormat,
 461                                                                          deUint32                               sampleCount)
 462 {
 463         const VkSampleCountFlagBits                             samples                                         (sampleCountBitFromomSampleCount(sampleCount));
 464         const deUint32                                                  splitSubpassCount                       (deDivRoundUp32(sampleCount, MAX_COLOR_ATTACHMENT_COUNT));
 465         const tcu::TextureFormat                                format                                          (mapVkFormat(srcFormat));
 466         const bool                                                              isDepthStencilFormat            (tcu::hasDepthComponent(format.order) || tcu::hasStencilComponent(format.order));
 467         vector<VkSubpassDescription>                    subpasses;
 468         vector<vector<VkAttachmentReference> >  dstAttachmentRefs                       (splitSubpassCount);
 469         vector<vector<VkAttachmentReference> >  dstResolveAttachmentRefs        (splitSubpassCount);
 470         vector<VkAttachmentDescription>                 attachments;
 471         vector<VkSubpassDependency>                             dependencies;
 472         const VkAttachmentReference                             srcAttachmentRef =
 473         {
 474                 0u,
 475                 isDepthStencilFormat
 476                         ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
 477                         : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
 478         };
 479         const VkAttachmentReference                             srcAttachmentInputRef =
 480         {
 481                 0u,
 482                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
 483         };
 484
 485         {
 486                 const VkAttachmentDescription srcAttachment =
 487                 {
 488                         0u,
 489
 490                         srcFormat,
 491                         samples,
 492
 493                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 494                         VK_ATTACHMENT_STORE_OP_DONT_CARE,
 495
 496                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 497                         VK_ATTACHMENT_STORE_OP_DONT_CARE,
 498
 499                         VK_IMAGE_LAYOUT_UNDEFINED,
 500                         VK_IMAGE_LAYOUT_GENERAL
 501                 };
 502
 503                 attachments.push_back(srcAttachment);
 504         }
 505
 506         for (deUint32 splitSubpassIndex = 0; splitSubpassIndex < splitSubpassCount; splitSubpassIndex++)
 507         {
 508                 for (deUint32 sampleNdx = 0; sampleNdx < de::min((deUint32)MAX_COLOR_ATTACHMENT_COUNT, sampleCount  - splitSubpassIndex * MAX_COLOR_ATTACHMENT_COUNT); sampleNdx++)
 509                 {
 510                         // Multisample color attachment
 511                         {
 512                                 const VkAttachmentDescription dstAttachment =
 513                                 {
 514                                         0u,
 515
 516                                         dstFormat,
 517                                         samples,
 518
 519                                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 520                                         VK_ATTACHMENT_STORE_OP_DONT_CARE,
 521
 522                                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 523                                         VK_ATTACHMENT_STORE_OP_DONT_CARE,
 524
 525                                         VK_IMAGE_LAYOUT_UNDEFINED,
 526                                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
 527                                 };
 528                                 const VkAttachmentReference dstAttachmentRef =
 529                                 {
 530                                         (deUint32)attachments.size(),
 531                                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
 532                                 };
 533
 534                                 attachments.push_back(dstAttachment);
 535                                 dstAttachmentRefs[splitSubpassIndex].push_back(dstAttachmentRef);
 536                         }
 537                         // Resolve attachment
 538                         {
 539                                 const VkAttachmentDescription dstAttachment =
 540                                 {
 541                                         0u,
 542
 543                                         dstFormat,
 544                                         VK_SAMPLE_COUNT_1_BIT,
 545
 546                                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 547                                         VK_ATTACHMENT_STORE_OP_STORE,
 548
 549                                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 550                                         VK_ATTACHMENT_STORE_OP_STORE,
 551
 552                                         VK_IMAGE_LAYOUT_UNDEFINED,
 553                                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
 554                                 };
 555                                 const VkAttachmentReference dstAttachmentRef =
 556                                 {
 557                                         (deUint32)attachments.size(),
 558                                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
 559                                 };
 560
 561                                 attachments.push_back(dstAttachment);
 562                                 dstResolveAttachmentRefs[splitSubpassIndex].push_back(dstAttachmentRef);
 563                         }
 564                 }
 565         }
 566
 567         {
 568                 {
 569                         const VkSubpassDescription      subpass =
 570                         {
 571                                 (VkSubpassDescriptionFlags)0,
 572                                 VK_PIPELINE_BIND_POINT_GRAPHICS,
 573
 574                                 0u,
 575                                 DE_NULL,
 576
 577                                 isDepthStencilFormat ? 0u : 1u,
 578                                 isDepthStencilFormat ? DE_NULL : &srcAttachmentRef,
 579                                 DE_NULL,
 580
 581                                 isDepthStencilFormat ? &srcAttachmentRef : DE_NULL,
 582                                 0u,
 583                                 DE_NULL
 584                         };
 585
 586                         subpasses.push_back(subpass);
 587                 }
 588
 589                 for (deUint32 splitSubpassIndex = 0; splitSubpassIndex < splitSubpassCount; splitSubpassIndex++)
 590                 {
 591                         {
 592                                 const VkSubpassDescription      subpass =
 593                                 {
 594                                         (VkSubpassDescriptionFlags)0,
 595                                         VK_PIPELINE_BIND_POINT_GRAPHICS,
 596
 597                                         1u,
 598                                         &srcAttachmentInputRef,
 599
 600                                         (deUint32)dstAttachmentRefs[splitSubpassIndex].size(),
 601                                         &dstAttachmentRefs[splitSubpassIndex][0],
 602                                         &dstResolveAttachmentRefs[splitSubpassIndex][0],
 603
 604                                         DE_NULL,
 605                                         0u,
 606                                         DE_NULL
 607                                 };
 608                                 subpasses.push_back(subpass);
 609                         }
 610                         {
 611                                 const VkSubpassDependency               dependency      =
 612                                 {
 613                                         0u, splitSubpassIndex + 1,
 614                                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
 615                                         VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
 616
 617                                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
 618                                         VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
 619
 620                                         VK_DEPENDENCY_BY_REGION_BIT
 621                                 };
 622
 623                                 dependencies.push_back(dependency);
 624                         }
 625                 };
 626                 const VkRenderPassCreateInfo    createInfo      =
 627                 {
 628                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
 629                         DE_NULL,
 630                         (VkRenderPassCreateFlags)0u,
 631
 632                         (deUint32)attachments.size(),
 633                         &attachments[0],
 634
 635                         (deUint32)subpasses.size(),
 636                         &subpasses[0],
 637
 638                         (deUint32)dependencies.size(),
 639                         &dependencies[0]
 640                 };
 641
 642                 return createRenderPass(vkd, device, &createInfo);
 643         }
 644 }
 645
 646 Move<VkFramebuffer> createFramebuffer (const DeviceInterface&                           vkd,
 647                                                                            VkDevice                                                             device,
 648                                                                            VkRenderPass                                                 renderPass,
 649                                                                            VkImageView                                                  srcImageView,
 650                                                                            const std::vector<VkImageViewSp>&    dstMultisampleImageViews,
 651                                                                            const std::vector<VkImageViewSp>&    dstSinglesampleImageViews,
 652                                                                            deUint32                                                             width,
 653                                                                            deUint32                                                             height)
 654 {
 655         std::vector<VkImageView> attachments;
 656
 657         attachments.reserve(dstMultisampleImageViews.size() + dstSinglesampleImageViews.size() + 1u);
 658
 659         attachments.push_back(srcImageView);
 660
 661         DE_ASSERT(dstMultisampleImageViews.size() == dstSinglesampleImageViews.size());
 662
 663         for (size_t ndx = 0; ndx < dstMultisampleImageViews.size(); ndx++)
 664         {
 665                 attachments.push_back(**dstMultisampleImageViews[ndx]);
 666                 attachments.push_back(**dstSinglesampleImageViews[ndx]);
 667         }
 668
 669         const VkFramebufferCreateInfo createInfo =
 670         {
 671                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
 672                 DE_NULL,
 673                 0u,
 674
 675                 renderPass,
 676                 (deUint32)attachments.size(),
 677                 &attachments[0],
 678
 679                 width,
 680                 height,
 681                 1u
 682         };
 683
 684         return createFramebuffer(vkd, device, &createInfo);
 685 }
 686
 687 Move<VkPipelineLayout> createRenderPipelineLayout (const DeviceInterface&       vkd,
 688                                                                                                    VkDevice                                     device)
 689 {
 690         const VkPushConstantRange                       pushConstant                    =
 691         {
 692                 VK_SHADER_STAGE_FRAGMENT_BIT,
 693                 0u,
 694                 4u
 695         };
 696         const VkPipelineLayoutCreateInfo        createInfo      =
 697         {
 698                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
 699                 DE_NULL,
 700                 (vk::VkPipelineLayoutCreateFlags)0,
 701
 702                 0u,
 703                 DE_NULL,
 704
 705                 1u,
 706                 &pushConstant
 707         };
 708
 709         return createPipelineLayout(vkd, device, &createInfo);
 710 }
 711
 712 Move<VkPipeline> createRenderPipeline (const DeviceInterface&                                                   vkd,
 713                                                                            VkDevice                                                                                     device,
 714                                                                            VkFormat                                                                                     srcFormat,
 715                                                                            VkRenderPass                                                                         renderPass,
 716                                                                            VkPipelineLayout                                                                     pipelineLayout,
 717                                                                            const vk::ProgramCollection<vk::ProgramBinary>&      binaryCollection,
 718                                                                            deUint32                                                                                     width,
 719                                                                            deUint32                                                                                     height,
 720                                                                            deUint32                                                                                     sampleCount)
 721 {
 722         const tcu::TextureFormat                format                                          (mapVkFormat(srcFormat));
 723         const bool                                              isDepthStencilFormat            (tcu::hasDepthComponent(format.order) || tcu::hasStencilComponent(format.order));
 724
 725         const Unique<VkShaderModule>    vertexShaderModule                      (createShaderModule(vkd, device, binaryCollection.get("quad-vert"), 0u));
 726         const Unique<VkShaderModule>    fragmentShaderModule            (createShaderModule(vkd, device, binaryCollection.get("quad-frag"), 0u));
 727         const VkSpecializationInfo              emptyShaderSpecializations      =
 728         {
 729                 0u,
 730                 DE_NULL,
 731
 732                 0u,
 733                 DE_NULL
 734         };
 735         // Disable blending
 736         const VkPipelineColorBlendAttachmentState attachmentBlendState =
 737         {
 738                 VK_FALSE,
 739                 VK_BLEND_FACTOR_SRC_ALPHA,
 740                 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
 741                 VK_BLEND_OP_ADD,
 742                 VK_BLEND_FACTOR_ONE,
 743                 VK_BLEND_FACTOR_ONE,
 744                 VK_BLEND_OP_ADD,
 745                 VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT
 746         };
 747         const VkPipelineShaderStageCreateInfo shaderStages[2] =
 748         {
 749                 {
 750                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 751                         DE_NULL,
 752                         (VkPipelineShaderStageCreateFlags)0u,
 753                         VK_SHADER_STAGE_VERTEX_BIT,
 754                         *vertexShaderModule,
 755                         "main",
 756                         &emptyShaderSpecializations
 757                 },
 758                 {
 759                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 760                         DE_NULL,
 761                         (VkPipelineShaderStageCreateFlags)0u,
 762                         VK_SHADER_STAGE_FRAGMENT_BIT,
 763                         *fragmentShaderModule,
 764                         "main",
 765                         &emptyShaderSpecializations
 766                 }
 767         };
 768         const VkPipelineVertexInputStateCreateInfo vertexInputState =
 769         {
 770                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
 771                 DE_NULL,
 772                 (VkPipelineVertexInputStateCreateFlags)0u,
 773
 774                 0u,
 775                 DE_NULL,
 776
 777                 0u,
 778                 DE_NULL
 779         };
 780         const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
 781         {
 782                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
 783                 DE_NULL,
 784
 785                 (VkPipelineInputAssemblyStateCreateFlags)0u,
 786                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 787                 VK_FALSE
 788         };
 789         const VkViewport viewport =
 790         {
 791                 0.0f,  0.0f,
 792                 (float)width, (float)height,
 793
 794                 0.0f, 1.0f
 795         };
 796         const VkRect2D scissor =
 797         {
 798                 { 0u, 0u },
 799                 { width, height }
 800         };
 801         const VkPipelineViewportStateCreateInfo viewportState =
 802         {
 803                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
 804                 DE_NULL,
 805                 (VkPipelineViewportStateCreateFlags)0u,
 806
 807                 1u,
 808                 &viewport,
 809
 810                 1u,
 811                 &scissor
 812         };
 813         const VkPipelineRasterizationStateCreateInfo rasterState =
 814         {
 815                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
 816                 DE_NULL,
 817                 (VkPipelineRasterizationStateCreateFlags)0u,
 818                 VK_TRUE,
 819                 VK_FALSE,
 820                 VK_POLYGON_MODE_FILL,
 821                 VK_CULL_MODE_NONE,
 822                 VK_FRONT_FACE_COUNTER_CLOCKWISE,
 823                 VK_FALSE,
 824                 0.0f,
 825                 0.0f,
 826                 0.0f,
 827                 1.0f
 828         };
 829         const VkPipelineMultisampleStateCreateInfo multisampleState =
 830         {
 831                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
 832                 DE_NULL,
 833                 (VkPipelineMultisampleStateCreateFlags)0u,
 834
 835                 sampleCountBitFromomSampleCount(sampleCount),
 836                 VK_FALSE,
 837                 0.0f,
 838                 DE_NULL,
 839                 VK_FALSE,
 840                 VK_FALSE,
 841         };
 842         const VkPipelineDepthStencilStateCreateInfo depthStencilState =
 843         {
 844                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
 845                 DE_NULL,
 846                 (VkPipelineDepthStencilStateCreateFlags)0u,
 847
 848                 VK_TRUE,
 849                 VK_TRUE,
 850                 VK_COMPARE_OP_ALWAYS,
 851                 VK_FALSE,
 852                 VK_TRUE,
 853                 {
 854                         VK_STENCIL_OP_KEEP,
 855                         VK_STENCIL_OP_INCREMENT_AND_WRAP,
 856                         VK_STENCIL_OP_KEEP,
 857                         VK_COMPARE_OP_ALWAYS,
 858                         ~0u,
 859                         ~0u,
 860                         0xFFu / (sampleCount + 1)
 861                 },
 862                 {
 863                         VK_STENCIL_OP_KEEP,
 864                         VK_STENCIL_OP_INCREMENT_AND_WRAP,
 865                         VK_STENCIL_OP_KEEP,
 866                         VK_COMPARE_OP_ALWAYS,
 867                         ~0u,
 868                         ~0u,
 869                         0xFFu / (sampleCount + 1)
 870                 },
 871
 872                 0.0f,
 873                 1.0f
 874         };
 875         const VkPipelineColorBlendStateCreateInfo blendState =
 876         {
 877                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
 878                 DE_NULL,
 879                 (VkPipelineColorBlendStateCreateFlags)0u,
 880
 881                 VK_FALSE,
 882                 VK_LOGIC_OP_COPY,
 883                 (isDepthStencilFormat ? 0u : 1u),
 884                 (isDepthStencilFormat ? DE_NULL : &attachmentBlendState),
 885                 { 0.0f, 0.0f, 0.0f, 0.0f }
 886         };
 887         const VkGraphicsPipelineCreateInfo createInfo =
 888         {
 889                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
 890                 DE_NULL,
 891                 (VkPipelineCreateFlags)0u,
 892
 893                 2,
 894                 shaderStages,
 895
 896                 &vertexInputState,
 897                 &inputAssemblyState,
 898                 DE_NULL,
 899                 &viewportState,
 900                 &rasterState,
 901                 &multisampleState,
 902                 &depthStencilState,
 903                 &blendState,
 904                 (const VkPipelineDynamicStateCreateInfo*)DE_NULL,
 905                 pipelineLayout,
 906
 907                 renderPass,
 908                 0u,
 909                 DE_NULL,
 910                 0u
 911         };
 912
 913         return createGraphicsPipeline(vkd, device, DE_NULL, &createInfo);
 914 }
 915
 916 Move<VkDescriptorSetLayout> createSplitDescriptorSetLayout (const DeviceInterface&      vkd,
 917                                                                                                                         VkDevice                                device,
 918                                                                                                                         VkFormat                                vkFormat)
 919 {
 920         const tcu::TextureFormat                                format          (mapVkFormat(vkFormat));
 921         const bool                                                              hasDepth        (tcu::hasDepthComponent(format.order));
 922         const bool                                                              hasStencil      (tcu::hasStencilComponent(format.order));
 923         const VkDescriptorSetLayoutBinding              bindings[]      =
 924         {
 925                 {
 926                         0u,
 927                         VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
 928                         1u,
 929                         VK_SHADER_STAGE_FRAGMENT_BIT,
 930                         DE_NULL
 931                 },
 932                 {
 933                         1u,
 934                         VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
 935                         1u,
 936                         VK_SHADER_STAGE_FRAGMENT_BIT,
 937                         DE_NULL
 938                 }
 939         };
 940         const VkDescriptorSetLayoutCreateInfo   createInfo      =
 941         {
 942                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
 943                 DE_NULL,
 944                 0u,
 945
 946                 hasDepth && hasStencil ? 2u : 1u,
 947                 bindings
 948         };
 949
 950         return createDescriptorSetLayout(vkd, device, &createInfo);
 951 }
 952
 953 Move<VkPipelineLayout> createSplitPipelineLayout (const DeviceInterface&        vkd,
 954                                                                                                   VkDevice                                      device,
 955                                                                                                   VkDescriptorSetLayout         descriptorSetLayout)
 956 {
 957         const VkPushConstantRange                       pushConstant                    =
 958         {
 959                 VK_SHADER_STAGE_FRAGMENT_BIT,
 960                 0u,
 961                 4u
 962         };
 963         const VkPipelineLayoutCreateInfo        createInfo      =
 964         {
 965                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
 966                 DE_NULL,
 967                 (vk::VkPipelineLayoutCreateFlags)0,
 968
 969                 1u,
 970                 &descriptorSetLayout,
 971
 972                 1u,
 973                 &pushConstant
 974         };
 975
 976         return createPipelineLayout(vkd, device, &createInfo);
 977 }
 978
 979 Move<VkPipeline> createSplitPipeline (const DeviceInterface&                                                    vkd,
 980                                                                           VkDevice                                                                                      device,
 981                                                                           VkRenderPass                                                                          renderPass,
 982                                                                           deUint32                                                                                      subpassIndex,
 983                                                                           VkPipelineLayout                                                                      pipelineLayout,
 984                                                                           const vk::ProgramCollection<vk::ProgramBinary>&       binaryCollection,
 985                                                                           deUint32                                                                                      width,
 986                                                                           deUint32                                                                                      height,
 987                                                                           deUint32                                                                                      sampleCount)
 988 {
 989         const Unique<VkShaderModule>    vertexShaderModule                      (createShaderModule(vkd, device, binaryCollection.get("quad-vert"), 0u));
 990         const Unique<VkShaderModule>    fragmentShaderModule            (createShaderModule(vkd, device, binaryCollection.get("quad-split-frag"), 0u));
 991         const VkSpecializationInfo              emptyShaderSpecializations      =
 992         {
 993                 0u,
 994                 DE_NULL,
 995
 996                 0u,
 997                 DE_NULL
 998         };
 999         // Disable blending
1000         const VkPipelineColorBlendAttachmentState attachmentBlendState =
1001         {
1002                 VK_FALSE,
1003                 VK_BLEND_FACTOR_SRC_ALPHA,
1004                 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
1005                 VK_BLEND_OP_ADD,
1006                 VK_BLEND_FACTOR_ONE,
1007                 VK_BLEND_FACTOR_ONE,
1008                 VK_BLEND_OP_ADD,
1009                 VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT
1010         };
1011         const std::vector<VkPipelineColorBlendAttachmentState> attachmentBlendStates (de::min((deUint32)MAX_COLOR_ATTACHMENT_COUNT, sampleCount), attachmentBlendState);
1012         const VkPipelineShaderStageCreateInfo shaderStages[2] =
1013         {
1014                 {
1015                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1016                         DE_NULL,
1017                         (VkPipelineShaderStageCreateFlags)0u,
1018                         VK_SHADER_STAGE_VERTEX_BIT,
1019                         *vertexShaderModule,
1020                         "main",
1021                         &emptyShaderSpecializations
1022                 },
1023                 {
1024                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1025                         DE_NULL,
1026                         (VkPipelineShaderStageCreateFlags)0u,
1027                         VK_SHADER_STAGE_FRAGMENT_BIT,
1028                         *fragmentShaderModule,
1029                         "main",
1030                         &emptyShaderSpecializations
1031                 }
1032         };
1033         const VkPipelineVertexInputStateCreateInfo vertexInputState =
1034         {
1035                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
1036                 DE_NULL,
1037                 (VkPipelineVertexInputStateCreateFlags)0u,
1038
1039                 0u,
1040                 DE_NULL,
1041
1042                 0u,
1043                 DE_NULL
1044         };
1045         const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
1046         {
1047                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
1048                 DE_NULL,
1049
1050                 (VkPipelineInputAssemblyStateCreateFlags)0u,
1051                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
1052                 VK_FALSE
1053         };
1054         const VkViewport viewport =
1055         {
1056                 0.0f,  0.0f,
1057                 (float)width, (float)height,
1058
1059                 0.0f, 1.0f
1060         };
1061         const VkRect2D scissor =
1062         {
1063                 { 0u, 0u },
1064                 { width, height }
1065         };
1066         const VkPipelineViewportStateCreateInfo viewportState =
1067         {
1068                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
1069                 DE_NULL,
1070                 (VkPipelineViewportStateCreateFlags)0u,
1071
1072                 1u,
1073                 &viewport,
1074
1075                 1u,
1076                 &scissor
1077         };
1078         const VkPipelineRasterizationStateCreateInfo rasterState =
1079         {
1080                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
1081                 DE_NULL,
1082                 (VkPipelineRasterizationStateCreateFlags)0u,
1083                 VK_TRUE,
1084                 VK_FALSE,
1085                 VK_POLYGON_MODE_FILL,
1086                 VK_CULL_MODE_NONE,
1087                 VK_FRONT_FACE_COUNTER_CLOCKWISE,
1088                 VK_FALSE,
1089                 0.0f,
1090                 0.0f,
1091                 0.0f,
1092                 1.0f
1093         };
1094         const VkPipelineMultisampleStateCreateInfo multisampleState =
1095         {
1096                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
1097                 DE_NULL,
1098                 (VkPipelineMultisampleStateCreateFlags)0u,
1099
1100                 sampleCountBitFromomSampleCount(sampleCount),
1101                 VK_FALSE,
1102                 0.0f,
1103                 DE_NULL,
1104                 VK_FALSE,
1105                 VK_FALSE,
1106         };
1107         const VkPipelineDepthStencilStateCreateInfo depthStencilState =
1108         {
1109                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
1110                 DE_NULL,
1111                 (VkPipelineDepthStencilStateCreateFlags)0u,
1112
1113                 VK_FALSE,
1114                 VK_FALSE,
1115                 VK_COMPARE_OP_ALWAYS,
1116                 VK_FALSE,
1117                 VK_FALSE,
1118                 {
1119                         VK_STENCIL_OP_REPLACE,
1120                         VK_STENCIL_OP_REPLACE,
1121                         VK_STENCIL_OP_REPLACE,
1122                         VK_COMPARE_OP_ALWAYS,
1123                         ~0u,
1124                         ~0u,
1125                         0x0u
1126                 },
1127                 {
1128                         VK_STENCIL_OP_REPLACE,
1129                         VK_STENCIL_OP_REPLACE,
1130                         VK_STENCIL_OP_REPLACE,
1131                         VK_COMPARE_OP_ALWAYS,
1132                         ~0u,
1133                         ~0u,
1134                         0x0u
1135                 },
1136
1137                 0.0f,
1138                 1.0f
1139         };
1140         const VkPipelineColorBlendStateCreateInfo blendState =
1141         {
1142                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
1143                 DE_NULL,
1144                 (VkPipelineColorBlendStateCreateFlags)0u,
1145
1146                 VK_FALSE,
1147                 VK_LOGIC_OP_COPY,
1148
1149                 (deUint32)attachmentBlendStates.size(),
1150                 &attachmentBlendStates[0],
1151
1152                 { 0.0f, 0.0f, 0.0f, 0.0f }
1153         };
1154         const VkGraphicsPipelineCreateInfo createInfo =
1155         {
1156                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
1157                 DE_NULL,
1158                 (VkPipelineCreateFlags)0u,
1159
1160                 2,
1161                 shaderStages,
1162
1163                 &vertexInputState,
1164                 &inputAssemblyState,
1165                 DE_NULL,
1166                 &viewportState,
1167                 &rasterState,
1168                 &multisampleState,
1169                 &depthStencilState,
1170                 &blendState,
1171                 (const VkPipelineDynamicStateCreateInfo*)DE_NULL,
1172                 pipelineLayout,
1173
1174                 renderPass,
1175                 subpassIndex,
1176                 DE_NULL,
1177                 0u
1178         };
1179
1180         return createGraphicsPipeline(vkd, device, DE_NULL, &createInfo);
1181 }
1182
1183 vector<VkPipelineSp> createSplitPipelines (const DeviceInterface&                                                       vkd,
1184                                                                                  VkDevice                                                                                       device,
1185                                                                                  VkRenderPass                                                                           renderPass,
1186                                                                                  VkPipelineLayout                                                                       pipelineLayout,
1187                                                                                  const vk::ProgramCollection<vk::ProgramBinary>&        binaryCollection,
1188                                                                                  deUint32                                                                                       width,
1189                                                                                  deUint32                                                                                       height,
1190                                                                                  deUint32                                                                                       sampleCount)
1191 {
1192         std::vector<VkPipelineSp> pipelines (deDivRoundUp32(sampleCount, MAX_COLOR_ATTACHMENT_COUNT), (VkPipelineSp)0u);
1193
1194         for (size_t ndx = 0; ndx < pipelines.size(); ndx++)
1195                 pipelines[ndx] = safeSharedPtr(new Unique<VkPipeline>(createSplitPipeline(vkd, device, renderPass, (deUint32)(ndx + 1), pipelineLayout, binaryCollection, width, height, sampleCount)));
1196
1197         return pipelines;
1198 }
1199
1200 Move<VkDescriptorPool> createSplitDescriptorPool (const DeviceInterface&        vkd,
1201                                                                                                   VkDevice                                      device)
1202 {
1203         const VkDescriptorPoolSize                      size            =
1204         {
1205                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 2u
1206         };
1207         const VkDescriptorPoolCreateInfo        createInfo      =
1208         {
1209                 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
1210                 DE_NULL,
1211                 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
1212
1213
1214                 2u,
1215                 1u,
1216                 &size
1217         };
1218
1219         return createDescriptorPool(vkd, device, &createInfo);
1220 }
1221
1222 Move<VkDescriptorSet> createSplitDescriptorSet (const DeviceInterface&  vkd,
1223                                                                                                 VkDevice                                device,
1224                                                                                                 VkDescriptorPool                pool,
1225                                                                                                 VkDescriptorSetLayout   layout,
1226                                                                                                 VkImageView                             primaryImageView,
1227                                                                                                 VkImageView                             secondaryImageView)
1228 {
1229         const VkDescriptorSetAllocateInfo       allocateInfo    =
1230         {
1231                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
1232                 DE_NULL,
1233
1234                 pool,
1235                 1u,
1236                 &layout
1237         };
1238         Move<VkDescriptorSet> set (allocateDescriptorSet(vkd, device, &allocateInfo));
1239
1240         {
1241                 const VkDescriptorImageInfo     imageInfos[]    =
1242                 {
1243                         {
1244                                 (VkSampler)0u,
1245                                 primaryImageView,
1246                                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
1247                         },
1248                         {
1249                                 (VkSampler)0u,
1250                                 secondaryImageView,
1251                                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
1252                         }
1253                 };
1254                 const VkWriteDescriptorSet      writes[]        =
1255                 {
1256                         {
1257                                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
1258                                 DE_NULL,
1259
1260                                 *set,
1261                                 0u,
1262                                 0u,
1263                                 1u,
1264                                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
1265                                 &imageInfos[0],
1266                                 DE_NULL,
1267                                 DE_NULL
1268                         },
1269                         {
1270                                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
1271                                 DE_NULL,
1272
1273                                 *set,
1274                                 1u,
1275                                 0u,
1276                                 1u,
1277                                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
1278                                 &imageInfos[1],
1279                                 DE_NULL,
1280                                 DE_NULL
1281                         }
1282                 };
1283                 const deUint32  count   = secondaryImageView != (VkImageView)0
1284                                                                 ? 2u
1285                                                                 : 1u;
1286
1287                 vkd.updateDescriptorSets(device, count, writes, 0u, DE_NULL);
1288         }
1289         return set;
1290 }
1291
1292 struct TestConfig
1293 {
1294                                 TestConfig              (VkFormat       format_,
1295                                                                  deUint32       sampleCount_)
1296                 : format                (format_)
1297                 , sampleCount   (sampleCount_)
1298         {
1299         }
1300
1301         VkFormat        format;
1302         deUint32        sampleCount;
1303 };
1304
1305 VkImageUsageFlags getSrcImageUsage (VkFormat vkFormat)
1306 {
1307         const tcu::TextureFormat        format          (mapVkFormat(vkFormat));
1308         const bool                                      hasDepth        (tcu::hasDepthComponent(format.order));
1309         const bool                                      hasStencil      (tcu::hasStencilComponent(format.order));
1310
1311         if (hasDepth || hasStencil)
1312                 return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
1313         else
1314                 return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
1315 }
1316
1317 VkFormat getDstFormat (VkFormat vkFormat)
1318 {
1319         const tcu::TextureFormat        format          (mapVkFormat(vkFormat));
1320         const bool                                      hasDepth        (tcu::hasDepthComponent(format.order));
1321         const bool                                      hasStencil      (tcu::hasStencilComponent(format.order));
1322
1323         if (hasDepth && hasStencil)
1324                 return VK_FORMAT_R32G32_SFLOAT;
1325         else if (hasDepth || hasStencil)
1326                 return VK_FORMAT_R32_SFLOAT;
1327         else
1328                 return vkFormat;
1329 }
1330
1331
1332 class MultisampleRenderPassTestInstance : public TestInstance
1333 {
1334 public:
1335                                         MultisampleRenderPassTestInstance       (Context& context, TestConfig config);
1336                                         ~MultisampleRenderPassTestInstance      (void);
1337
1338         tcu::TestStatus iterate                                                         (void);
1339
1340 private:
1341         const VkFormat                                                                  m_srcFormat;
1342         const VkFormat                                                                  m_dstFormat;
1343         const deUint32                                                                  m_sampleCount;
1344         const deUint32                                                                  m_width;
1345         const deUint32                                                                  m_height;
1346
1347         const VkImageAspectFlags                                                m_srcImageAspect;
1348         const VkImageUsageFlags                                                 m_srcImageUsage;
1349         const Unique<VkImage>                                                   m_srcImage;
1350         const de::UniquePtr<Allocation>                                 m_srcImageMemory;
1351         const Unique<VkImageView>                                               m_srcImageView;
1352         const Unique<VkImageView>                                               m_srcPrimaryInputImageView;
1353         const Unique<VkImageView>                                               m_srcSecondaryInputImageView;
1354
1355         const std::vector<VkImageSp>                                    m_dstMultisampleImages;
1356         const std::vector<de::SharedPtr<Allocation> >   m_dstMultisampleImageMemory;
1357         const std::vector<VkImageViewSp>                                m_dstMultisampleImageViews;
1358
1359         const std::vector<VkImageSp>                                    m_dstSinglesampleImages;
1360         const std::vector<de::SharedPtr<Allocation> >   m_dstSinglesampleImageMemory;
1361         const std::vector<VkImageViewSp>                                m_dstSinglesampleImageViews;
1362
1363         const std::vector<VkBufferSp>                                   m_dstBuffers;
1364         const std::vector<de::SharedPtr<Allocation> >   m_dstBufferMemory;
1365
1366         const Unique<VkRenderPass>                                              m_renderPass;
1367         const Unique<VkFramebuffer>                                             m_framebuffer;
1368
1369         const Unique<VkPipelineLayout>                                  m_renderPipelineLayout;
1370         const Unique<VkPipeline>                                                m_renderPipeline;
1371
1372         const Unique<VkDescriptorSetLayout>                             m_splitDescriptorSetLayout;
1373         const Unique<VkPipelineLayout>                                  m_splitPipelineLayout;
1374         const std::vector<VkPipelineSp>                                 m_splitPipelines;
1375         const Unique<VkDescriptorPool>                                  m_splitDescriptorPool;
1376         const Unique<VkDescriptorSet>                                   m_splitDescriptorSet;
1377
1378         const Unique<VkCommandPool>                                             m_commandPool;
1379         tcu::ResultCollector                                                    m_resultCollector;
1380 };
1381
1382 MultisampleRenderPassTestInstance::MultisampleRenderPassTestInstance (Context& context, TestConfig config)
1383         : TestInstance                                  (context)
1384         , m_srcFormat                                   (config.format)
1385         , m_dstFormat                                   (getDstFormat(config.format))
1386         , m_sampleCount                                 (config.sampleCount)
1387         , m_width                                               (32u)
1388         , m_height                                              (32u)
1389
1390         , m_srcImageAspect                              (getImageAspectFlags(m_srcFormat))
1391         , m_srcImageUsage                               (getSrcImageUsage(m_srcFormat))
1392         , m_srcImage                                    (createImage(context.getInstanceInterface(), context.getPhysicalDevice(), context.getDeviceInterface(), context.getDevice(), m_srcFormat, sampleCountBitFromomSampleCount(m_sampleCount), m_srcImageUsage, m_width, m_height))
1393         , m_srcImageMemory                              (createImageMemory(context.getDeviceInterface(), context.getDevice(), context.getDefaultAllocator(), *m_srcImage))
1394         , m_srcImageView                                (createImageAttachmentView(context.getDeviceInterface(), context.getDevice(), *m_srcImage, m_srcFormat, m_srcImageAspect))
1395         , m_srcPrimaryInputImageView    (createSrcPrimaryInputImageView(context.getDeviceInterface(), context.getDevice(), *m_srcImage, m_srcFormat, m_srcImageAspect))
1396         , m_srcSecondaryInputImageView  (createSrcSecondaryInputImageView(context.getDeviceInterface(), context.getDevice(), *m_srcImage, m_srcFormat, m_srcImageAspect))
1397
1398         , m_dstMultisampleImages                (createMultisampleImages(context.getInstanceInterface(), context.getPhysicalDevice(), context.getDeviceInterface(), context.getDevice(), m_dstFormat, m_sampleCount, m_width, m_height))
1399         , m_dstMultisampleImageMemory   (createImageMemory(context.getDeviceInterface(), context.getDevice(), context.getDefaultAllocator(), m_dstMultisampleImages))
1400         , m_dstMultisampleImageViews    (createImageAttachmentViews(context.getDeviceInterface(), context.getDevice(), m_dstMultisampleImages, m_dstFormat, VK_IMAGE_ASPECT_COLOR_BIT))
1401
1402         , m_dstSinglesampleImages               (createSingleSampleImages(context.getInstanceInterface(), context.getPhysicalDevice(), context.getDeviceInterface(), context.getDevice(), m_dstFormat, m_sampleCount, m_width, m_height))
1403         , m_dstSinglesampleImageMemory  (createImageMemory(context.getDeviceInterface(), context.getDevice(), context.getDefaultAllocator(), m_dstSinglesampleImages))
1404         , m_dstSinglesampleImageViews   (createImageAttachmentViews(context.getDeviceInterface(), context.getDevice(), m_dstSinglesampleImages, m_dstFormat, VK_IMAGE_ASPECT_COLOR_BIT))
1405
1406         , m_dstBuffers                                  (createBuffers(context.getDeviceInterface(), context.getDevice(), m_dstFormat, m_sampleCount, m_width, m_height))
1407         , m_dstBufferMemory                             (createBufferMemory(context.getDeviceInterface(), context.getDevice(), context.getDefaultAllocator(), m_dstBuffers))
1408
1409         , m_renderPass                                  (createRenderPass(context.getDeviceInterface(), context.getDevice(), m_srcFormat, m_dstFormat, m_sampleCount))
1410         , m_framebuffer                                 (createFramebuffer(context.getDeviceInterface(), context.getDevice(), *m_renderPass, *m_srcImageView, m_dstMultisampleImageViews, m_dstSinglesampleImageViews, m_width, m_height))
1411
1412         , m_renderPipelineLayout                (createRenderPipelineLayout(context.getDeviceInterface(), context.getDevice()))
1413         , m_renderPipeline                              (createRenderPipeline(context.getDeviceInterface(), context.getDevice(), m_srcFormat, *m_renderPass, *m_renderPipelineLayout, context.getBinaryCollection(), m_width, m_height, m_sampleCount))
1414
1415         , m_splitDescriptorSetLayout    (createSplitDescriptorSetLayout(context.getDeviceInterface(), context.getDevice(), m_srcFormat))
1416         , m_splitPipelineLayout                 (createSplitPipelineLayout(context.getDeviceInterface(), context.getDevice(), *m_splitDescriptorSetLayout))
1417         , m_splitPipelines                              (createSplitPipelines(context.getDeviceInterface(), context.getDevice(), *m_renderPass, *m_splitPipelineLayout, context.getBinaryCollection(), m_width, m_height, m_sampleCount))
1418         , m_splitDescriptorPool                 (createSplitDescriptorPool(context.getDeviceInterface(), context.getDevice()))
1419         , m_splitDescriptorSet                  (createSplitDescriptorSet(context.getDeviceInterface(), context.getDevice(), *m_splitDescriptorPool, *m_splitDescriptorSetLayout, *m_srcPrimaryInputImageView, *m_srcSecondaryInputImageView))
1420         , m_commandPool                                 (createCommandPool(context.getDeviceInterface(), context.getDevice(), VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, context.getUniversalQueueFamilyIndex()))
1421 {
1422 }
1423
1424 MultisampleRenderPassTestInstance::~MultisampleRenderPassTestInstance (void)
1425 {
1426 }
1427
1428 tcu::TestStatus MultisampleRenderPassTestInstance::iterate (void)
1429 {
1430         const DeviceInterface&                  vkd                             (m_context.getDeviceInterface());
1431         const VkDevice                                  device                  (m_context.getDevice());
1432         const Unique<VkCommandBuffer>   commandBuffer   (allocateCommandBuffer(vkd, device, *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1433
1434         {
1435                 const VkCommandBufferBeginInfo beginInfo =
1436                 {
1437                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1438                         DE_NULL,
1439
1440                         VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
1441                         DE_NULL
1442                 };
1443
1444                 VK_CHECK(vkd.beginCommandBuffer(*commandBuffer, &beginInfo));
1445         }
1446
1447         {
1448                 const VkRenderPassBeginInfo beginInfo =
1449                 {
1450                         VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
1451                         DE_NULL,
1452
1453                         *m_renderPass,
1454                         *m_framebuffer,
1455
1456                         {
1457                                 { 0u, 0u },
1458                                 { m_width, m_height }
1459                         },
1460
1461                         0u,
1462                         DE_NULL
1463                 };
1464                 vkd.cmdBeginRenderPass(*commandBuffer, &beginInfo, VK_SUBPASS_CONTENTS_INLINE);
1465
1466                 // Stencil needs to be cleared if it exists.
1467                 if (tcu::hasStencilComponent(mapVkFormat(m_srcFormat).order))
1468                 {
1469                         const VkClearAttachment clearAttachment =
1470                         {
1471                                 VK_IMAGE_ASPECT_STENCIL_BIT,                                            // VkImageAspectFlags   aspectMask;
1472                                 0,                                                                                                      // deUint32                             colorAttachment;
1473                                 makeClearValueDepthStencil(0, 0)                                        // VkClearValue                 clearValue;
1474                         };
1475
1476                         const VkClearRect clearRect =
1477                         {
1478                                 {
1479                                         { 0u, 0u },
1480                                         { m_width, m_height }
1481                                 },
1482                                 0,                                                                                                      // deUint32     baseArrayLayer;
1483                                 1                                                                                                       // deUint32     layerCount;
1484                         };
1485
1486                         vkd.cmdClearAttachments(*commandBuffer, 1, &clearAttachment, 1, &clearRect);
1487                 }
1488         }
1489
1490         vkd.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_renderPipeline);
1491
1492         for (deUint32 sampleNdx = 0; sampleNdx < m_sampleCount; sampleNdx++)
1493         {
1494                 vkd.cmdPushConstants(*commandBuffer, *m_renderPipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0u, sizeof(sampleNdx), &sampleNdx);
1495                 vkd.cmdDraw(*commandBuffer, 6u, 1u, 0u, 0u);
1496         }
1497
1498         for (deUint32 splitPipelineNdx = 0; splitPipelineNdx < m_splitPipelines.size(); splitPipelineNdx++)
1499         {
1500                 vkd.cmdNextSubpass(*commandBuffer, VK_SUBPASS_CONTENTS_INLINE);
1501
1502                 vkd.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, **m_splitPipelines[splitPipelineNdx]);
1503                 vkd.cmdBindDescriptorSets(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_splitPipelineLayout, 0u, 1u,  &*m_splitDescriptorSet, 0u, DE_NULL);
1504                 vkd.cmdPushConstants(*commandBuffer, *m_splitPipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0u, sizeof(splitPipelineNdx), &splitPipelineNdx);
1505                 vkd.cmdDraw(*commandBuffer, 6u, 1u, 0u, 0u);
1506         }
1507
1508         vkd.cmdEndRenderPass(*commandBuffer);
1509
1510         // Memory barriers between rendering and copies
1511         {
1512                 std::vector<VkImageMemoryBarrier> barriers;
1513
1514                 for (size_t dstNdx = 0; dstNdx < m_dstSinglesampleImages.size(); dstNdx++)
1515                 {
1516                         const VkImageMemoryBarrier barrier =
1517                         {
1518                                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
1519                                 DE_NULL,
1520
1521                                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
1522                                 VK_ACCESS_TRANSFER_READ_BIT,
1523
1524                                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1525                                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1526
1527                                 VK_QUEUE_FAMILY_IGNORED,
1528                                 VK_QUEUE_FAMILY_IGNORED,
1529
1530                                 **m_dstSinglesampleImages[dstNdx],
1531                                 {
1532                                         VK_IMAGE_ASPECT_COLOR_BIT,
1533                                         0u,
1534                                         1u,
1535                                         0u,
1536                                         1u
1537                                 }
1538                         };
1539
1540                         barriers.push_back(barrier);
1541                 }
1542
1543                 vkd.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, (deUint32)barriers.size(), &barriers[0]);
1544         }
1545
1546         // Copy image memory to buffers
1547         for (size_t dstNdx = 0; dstNdx < m_dstSinglesampleImages.size(); dstNdx++)
1548         {
1549                 const VkBufferImageCopy region =
1550                 {
1551                         0u,
1552                         0u,
1553                         0u,
1554                         {
1555                                 VK_IMAGE_ASPECT_COLOR_BIT,
1556                                 0u,
1557                                 0u,
1558                                 1u,
1559                         },
1560                         { 0u, 0u, 0u },
1561                         { m_width, m_height, 1u }
1562                 };
1563
1564                 vkd.cmdCopyImageToBuffer(*commandBuffer, **m_dstSinglesampleImages[dstNdx], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, **m_dstBuffers[dstNdx], 1u, &region);
1565         }
1566
1567         // Memory barriers between copies and host access
1568         {
1569                 std::vector<VkBufferMemoryBarrier> barriers;
1570
1571                 for (size_t dstNdx = 0; dstNdx < m_dstBuffers.size(); dstNdx++)
1572                 {
1573                         const VkBufferMemoryBarrier barrier =
1574                         {
1575                                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
1576                                 DE_NULL,
1577
1578                                 VK_ACCESS_TRANSFER_WRITE_BIT,
1579                                 VK_ACCESS_HOST_READ_BIT,
1580
1581                                 VK_QUEUE_FAMILY_IGNORED,
1582                                 VK_QUEUE_FAMILY_IGNORED,
1583
1584                                 **m_dstBuffers[dstNdx],
1585                                 0u,
1586                                 VK_WHOLE_SIZE
1587                         };
1588
1589                         barriers.push_back(barrier);
1590                 }
1591
1592                 vkd.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, (deUint32)barriers.size(), &barriers[0], 0u, DE_NULL);
1593         }
1594
1595         VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
1596
1597         {
1598                 const VkSubmitInfo submitInfo =
1599                 {
1600                         VK_STRUCTURE_TYPE_SUBMIT_INFO,
1601                         DE_NULL,
1602
1603                         0u,
1604                         DE_NULL,
1605                         DE_NULL,
1606
1607                         1u,
1608                         &*commandBuffer,
1609
1610                         0u,
1611                         DE_NULL
1612                 };
1613
1614                 VK_CHECK(vkd.queueSubmit(m_context.getUniversalQueue(), 1u, &submitInfo, (VkFence)0u));
1615
1616                 VK_CHECK(vkd.queueWaitIdle(m_context.getUniversalQueue()));
1617         }
1618
1619         {
1620                 const tcu::TextureFormat                format                  (mapVkFormat(m_dstFormat));
1621                 const tcu::TextureFormat                srcFormat               (mapVkFormat(m_srcFormat));
1622                 const bool                                              hasDepth                (tcu::hasDepthComponent(srcFormat.order));
1623                 const bool                                              hasStencil              (tcu::hasStencilComponent(srcFormat.order));
1624
1625                 for (deUint32 sampleNdx = 0; sampleNdx < m_sampleCount; sampleNdx++)
1626                 {
1627                         const std::string                                       name            ("Sample" + de::toString(sampleNdx));
1628                         const void* const                                       ptr                     (m_dstBufferMemory[sampleNdx]->getHostPtr());
1629                         const tcu::ConstPixelBufferAccess       access          (format, m_width, m_height, 1, ptr);
1630                         tcu::TextureLevel                                       reference       (format, m_width, m_height);
1631
1632                         if (hasDepth || hasStencil)
1633                         {
1634                                 if (hasDepth)
1635                                 {
1636                                         for (deUint32 y = 0; y < m_height; y++)
1637                                         for (deUint32 x = 0; x < m_width; x++)
1638                                         {
1639                                                 const deUint32  x1                              = x ^ sampleNdx;
1640                                                 const deUint32  y1                              = y ^ sampleNdx;
1641                                                 const float             range                   = 1.0f;
1642                                                 float                   depth                   = 0.0f;
1643                                                 deUint32                divider                 = 2;
1644
1645                                                 // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
1646                                                 for (size_t bitNdx = 0; bitNdx < 10; bitNdx++)
1647                                                 {
1648                                                         depth += (range / (float)divider)
1649                                                                         * (((bitNdx % 2 == 0 ? x1 : y1) & (0x1u << (bitNdx / 2u))) == 0u ? 0u : 1u);
1650                                                         divider *= 2;
1651                                                 }
1652
1653                                                 reference.getAccess().setPixel(Vec4(depth, 0.0f, 0.0f, 0.0f), x, y);
1654                                         }
1655                                 }
1656                                 if (hasStencil)
1657                                 {
1658                                         for (deUint32 y = 0; y < m_height; y++)
1659                                         for (deUint32 x = 0; x < m_width; x++)
1660                                         {
1661                                                 const deUint32  stencil = sampleNdx + 1u;
1662
1663                                                 if (hasDepth)
1664                                                 {
1665                                                         const Vec4 src (reference.getAccess().getPixel(x, y));
1666
1667                                                         reference.getAccess().setPixel(Vec4(src.x(), (float)stencil, 0.0f, 0.0f), x, y);
1668                                                 }
1669                                                 else
1670                                                         reference.getAccess().setPixel(Vec4((float)stencil, 0.0f, 0.0f, 0.0f), x, y);
1671                                         }
1672                                 }
1673                                 {
1674                                         const Vec4 threshold (hasDepth ? (1.0f / 1024.0f) : 0.0f, 0.0f, 0.0f, 0.0f);
1675
1676                                         if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), name.c_str(), name.c_str(), reference.getAccess(), access, threshold, tcu::COMPARE_LOG_ON_ERROR))
1677                                                 m_resultCollector.fail("Compare failed for sample " + de::toString(sampleNdx));
1678                                 }
1679                         }
1680                         else
1681                         {
1682                                 const tcu::TextureChannelClass  channelClass    (tcu::getTextureChannelClass(format.type));
1683
1684                                 switch (channelClass)
1685                                 {
1686                                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1687                                         {
1688                                                 const UVec4             bits                    (tcu::getTextureFormatBitDepth(format).cast<deUint32>());
1689                                                 const UVec4             minValue                (0);
1690                                                 const UVec4             range                   (UVec4(1u) << tcu::min(bits, UVec4(31)));
1691                                                 const int               componentCount  (tcu::getNumUsedChannels(format.order));
1692                                                 const deUint32  bitSize                 (bits[0] + bits[1] + bits[2] + bits[3]);
1693
1694                                                 for (deUint32 y = 0; y < m_height; y++)
1695                                                 for (deUint32 x = 0; x < m_width; x++)
1696                                                 {
1697                                                         const deUint32  x1                              = x ^ sampleNdx;
1698                                                         const deUint32  y1                              = y ^ sampleNdx;
1699                                                         UVec4                   color                   (minValue);
1700                                                         deUint32                dstBitsUsed[4]  = { 0u, 0u, 0u, 0u };
1701                                                         deUint32                nextSrcBit              = 0;
1702                                                         deUint32                divider                 = 2;
1703
1704                                                         // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
1705                                                         while (nextSrcBit < de::min(bitSize, 10u))
1706                                                         {
1707                                                                 for (int compNdx = 0; compNdx < componentCount; compNdx++)
1708                                                                 {
1709                                                                         if (dstBitsUsed[compNdx] > bits[compNdx])
1710                                                                                 continue;
1711
1712                                                                         color[compNdx] += (range[compNdx] / divider)
1713                                                                                                         * (((nextSrcBit % 2 == 0 ? x1 : y1) & (0x1u << (nextSrcBit / 2u))) == 0u ? 0u : 1u);
1714
1715                                                                         nextSrcBit++;
1716                                                                         dstBitsUsed[compNdx]++;
1717                                                                 }
1718
1719                                                                 divider *= 2;
1720                                                         }
1721
1722                                                         reference.getAccess().setPixel(color, x, y);
1723                                                 }
1724
1725                                                 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), name.c_str(), name.c_str(), reference.getAccess(), access, UVec4(0u), tcu::COMPARE_LOG_ON_ERROR))
1726                                                         m_resultCollector.fail("Compare failed for sample " + de::toString(sampleNdx));
1727
1728                                                 break;
1729                                         }
1730
1731                                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1732                                         {
1733                                                 const UVec4             bits                    (tcu::getTextureFormatBitDepth(format).cast<deUint32>());
1734                                                 const IVec4             minValue                (0);
1735                                                 const IVec4             range                   ((UVec4(1u) << tcu::min(bits, UVec4(30))).cast<deInt32>());
1736                                                 const int               componentCount  (tcu::getNumUsedChannels(format.order));
1737                                                 const deUint32  bitSize                 (bits[0] + bits[1] + bits[2] + bits[3]);
1738
1739                                                 for (deUint32 y = 0; y < m_height; y++)
1740                                                 for (deUint32 x = 0; x < m_width; x++)
1741                                                 {
1742                                                         const deUint32  x1                              = x ^ sampleNdx;
1743                                                         const deUint32  y1                              = y ^ sampleNdx;
1744                                                         IVec4                   color                   (minValue);
1745                                                         deUint32                dstBitsUsed[4]  = { 0u, 0u, 0u, 0u };
1746                                                         deUint32                nextSrcBit              = 0;
1747                                                         deUint32                divider                 = 2;
1748
1749                                                         // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
1750                                                         while (nextSrcBit < de::min(bitSize, 10u))
1751                                                         {
1752                                                                 for (int compNdx = 0; compNdx < componentCount; compNdx++)
1753                                                                 {
1754                                                                         if (dstBitsUsed[compNdx] > bits[compNdx])
1755                                                                                 continue;
1756
1757                                                                         color[compNdx] += (range[compNdx] / divider)
1758                                                                                                         * (((nextSrcBit % 2 == 0 ? x1 : y1) & (0x1u << (nextSrcBit / 2u))) == 0u ? 0u : 1u);
1759
1760                                                                         nextSrcBit++;
1761                                                                         dstBitsUsed[compNdx]++;
1762                                                                 }
1763
1764                                                                 divider *= 2;
1765                                                         }
1766
1767                                                         reference.getAccess().setPixel(color, x, y);
1768                                                 }
1769
1770                                                 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), name.c_str(), name.c_str(), reference.getAccess(), access, UVec4(0u), tcu::COMPARE_LOG_ON_ERROR))
1771                                                         m_resultCollector.fail("Compare failed for sample " + de::toString(sampleNdx));
1772
1773                                                 break;
1774                                         }
1775
1776                                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
1777                                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
1778                                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
1779                                         {
1780                                                 const tcu::TextureFormatInfo    info                    (tcu::getTextureFormatInfo(format));
1781                                                 const UVec4                                             bits                    (tcu::getTextureFormatBitDepth(format).cast<deUint32>());
1782                                                 const Vec4                                              minLimit                (-65536.0);
1783                                                 const Vec4                                              maxLimit                (65536.0);
1784                                                 const Vec4                                              minValue                (tcu::max(info.valueMin, minLimit));
1785                                                 const Vec4                                              range                   (tcu::min(info.valueMax, maxLimit) - minValue);
1786                                                 const int                                               componentCount  (tcu::getNumUsedChannels(format.order));
1787                                                 const deUint32                                  bitSize                 (bits[0] + bits[1] + bits[2] + bits[3]);
1788
1789                                                 for (deUint32 y = 0; y < m_height; y++)
1790                                                 for (deUint32 x = 0; x < m_width; x++)
1791                                                 {
1792                                                         const deUint32  x1                              = x ^ sampleNdx;
1793                                                         const deUint32  y1                              = y ^ sampleNdx;
1794                                                         Vec4                    color                   (minValue);
1795                                                         deUint32                dstBitsUsed[4]  = { 0u, 0u, 0u, 0u };
1796                                                         deUint32                nextSrcBit              = 0;
1797                                                         deUint32                divider                 = 2;
1798
1799                                                         // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
1800                                                         while (nextSrcBit < de::min(bitSize, 10u))
1801                                                         {
1802                                                                 for (int compNdx = 0; compNdx < componentCount; compNdx++)
1803                                                                 {
1804                                                                         if (dstBitsUsed[compNdx] > bits[compNdx])
1805                                                                                 continue;
1806
1807                                                                         color[compNdx] += (range[compNdx] / (float)divider)
1808                                                                                                         * (((nextSrcBit % 2 == 0 ? x1 : y1) & (0x1u << (nextSrcBit / 2u))) == 0u ? 0u : 1u);
1809
1810                                                                         nextSrcBit++;
1811                                                                         dstBitsUsed[compNdx]++;
1812                                                                 }
1813
1814                                                                 divider *= 2;
1815                                                         }
1816
1817                                                         if (tcu::isSRGB(format))
1818                                                                 reference.getAccess().setPixel(tcu::linearToSRGB(color), x, y);
1819                                                         else
1820                                                                 reference.getAccess().setPixel(color, x, y);
1821                                                 }
1822
1823                                                 if (channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT)
1824                                                 {
1825                                                         // Convert target format ulps to float ulps and allow 64ulp differences
1826                                                         const UVec4 threshold (64u * (UVec4(1u) << (UVec4(23) - tcu::getTextureFormatMantissaBitDepth(format).cast<deUint32>())));
1827
1828                                                         if (!tcu::floatUlpThresholdCompare(m_context.getTestContext().getLog(), name.c_str(), name.c_str(), reference.getAccess(), access, threshold, tcu::COMPARE_LOG_ON_ERROR))
1829                                                                 m_resultCollector.fail("Compare failed for sample " + de::toString(sampleNdx));
1830                                                 }
1831                                                 else
1832                                                 {
1833                                                         // Allow error of 4 times the minimum presentable difference
1834                                                         const Vec4 threshold (4.0f * 1.0f / ((UVec4(1u) << tcu::getTextureFormatMantissaBitDepth(format).cast<deUint32>()) - 1u).cast<float>());
1835
1836                                                         if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), name.c_str(), name.c_str(), reference.getAccess(), access, threshold, tcu::COMPARE_LOG_ON_ERROR))
1837                                                                 m_resultCollector.fail("Compare failed for sample " + de::toString(sampleNdx));
1838                                                 }
1839
1840                                                 break;
1841                                         }
1842
1843                                         default:
1844                                                 DE_FATAL("Unknown channel class");
1845                                 }
1846                         }
1847                 }
1848         }
1849
1850         return tcu::TestStatus(m_resultCollector.getResult(), m_resultCollector.getMessage());
1851 }
1852
1853 struct Programs
1854 {
1855         void init (vk::SourceCollections& dst, TestConfig config) const
1856         {
1857                 const tcu::TextureFormat                format                  (mapVkFormat(config.format));
1858                 const tcu::TextureChannelClass  channelClass    (tcu::getTextureChannelClass(format.type));
1859
1860                 dst.glslSources.add("quad-vert") << glu::VertexSource(
1861                         "#version 450\n"
1862                         "out gl_PerVertex {\n"
1863                         "\tvec4 gl_Position;\n"
1864                         "};\n"
1865                         "highp float;\n"
1866                         "void main (void) {\n"
1867                         "\tgl_Position = vec4(((gl_VertexIndex + 2) / 3) % 2 == 0 ? -1.0 : 1.0,\n"
1868                         "\t                   ((gl_VertexIndex + 1) / 3) % 2 == 0 ? -1.0 : 1.0, 0.0, 1.0);\n"
1869                         "}\n");
1870
1871                 if (tcu::hasDepthComponent(format.order))
1872                 {
1873                         const Vec4                      minValue                (0.0f);
1874                         const Vec4                      range                   (1.0f);
1875                         std::ostringstream      fragmentShader;
1876
1877                         fragmentShader <<
1878                                 "#version 450\n"
1879                                 "layout(push_constant) uniform PushConstant {\n"
1880                                 "\thighp uint sampleIndex;\n"
1881                                 "} pushConstants;\n"
1882                                 "void main (void)\n"
1883                                 "{\n"
1884                                 "\thighp uint sampleIndex = pushConstants.sampleIndex;\n"
1885                                 "\tgl_SampleMask[0] = int((~0x0u) << sampleIndex);\n"
1886                                 "\thighp float depth;\n"
1887                                 "\thighp uint x = sampleIndex ^ uint(gl_FragCoord.x);\n"
1888                                 "\thighp uint y = sampleIndex ^ uint(gl_FragCoord.y);\n";
1889
1890                         fragmentShader << "\tdepth = "  << minValue[0] << ";\n";
1891
1892                         {
1893                                 deUint32 divider = 2;
1894
1895                                 // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
1896                                 for (size_t bitNdx = 0; bitNdx < 10; bitNdx++)
1897                                 {
1898                                         fragmentShader <<
1899                                                         "\tdepth += " << (range[0] / (float)divider)
1900                                                         << " * float(bitfieldExtract(" << (bitNdx % 2 == 0 ? "x" : "y") << ", " << (bitNdx / 2) << ", 1));\n";
1901
1902                                         divider *= 2;
1903                                 }
1904                         }
1905
1906                         fragmentShader <<
1907                                 "\tgl_FragDepth = depth;\n"
1908                                 "}\n";
1909
1910                         dst.glslSources.add("quad-frag") << glu::FragmentSource(fragmentShader.str());
1911                 }
1912                 else if (tcu::hasStencilComponent(format.order))
1913                 {
1914                         dst.glslSources.add("quad-frag") << glu::FragmentSource(
1915                                 "#version 450\n"
1916                                 "layout(push_constant) uniform PushConstant {\n"
1917                                 "\thighp uint sampleIndex;\n"
1918                                 "} pushConstants;\n"
1919                                 "void main (void)\n"
1920                                 "{\n"
1921                                 "\thighp uint sampleIndex = pushConstants.sampleIndex;\n"
1922                                 "\tgl_SampleMask[0] = int((~0x0u) << sampleIndex);\n"
1923                                 "}\n");
1924                 }
1925                 else
1926                 {
1927                         switch (channelClass)
1928                         {
1929                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
1930                                 {
1931                                         const UVec4     bits            (tcu::getTextureFormatBitDepth(format).cast<deUint32>());
1932                                         const UVec4 minValue    (0);
1933                                         const UVec4 range               (UVec4(1u) << tcu::min(bits, UVec4(31)));
1934                                         std::ostringstream              fragmentShader;
1935
1936                                         fragmentShader <<
1937                                                 "#version 450\n"
1938                                                 "layout(location = 0) out highp uvec4 o_color;\n"
1939                                                 "layout(push_constant) uniform PushConstant {\n"
1940                                                 "\thighp uint sampleIndex;\n"
1941                                                 "} pushConstants;\n"
1942                                                 "void main (void)\n"
1943                                                 "{\n"
1944                                                 "\thighp uint sampleIndex = pushConstants.sampleIndex;\n"
1945                                                 "\tgl_SampleMask[0] = int(0x1u << sampleIndex);\n"
1946                                                 "\thighp uint color[4];\n"
1947                                                 "\thighp uint x = sampleIndex ^ uint(gl_FragCoord.x);\n"
1948                                                 "\thighp uint y = sampleIndex ^ uint(gl_FragCoord.y);\n";
1949
1950                                         for (int ndx = 0; ndx < 4; ndx++)
1951                                                 fragmentShader << "\tcolor[" << ndx << "] = "  << minValue[ndx] << ";\n";
1952
1953                                         {
1954                                                 const int               componentCount  = tcu::getNumUsedChannels(format.order);
1955                                                 const deUint32  bitSize                 (bits[0] + bits[1] + bits[2] + bits[3]);
1956                                                 deUint32                dstBitsUsed[4]  = { 0u, 0u, 0u, 0u };
1957                                                 deUint32                nextSrcBit              = 0;
1958                                                 deUint32                divider                 = 2;
1959
1960                                                 // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
1961                                                 while (nextSrcBit < de::min(bitSize, 10u))
1962                                                 {
1963                                                         for (int compNdx = 0; compNdx < componentCount; compNdx++)
1964                                                         {
1965                                                                 if (dstBitsUsed[compNdx] > bits[compNdx])
1966                                                                         continue;
1967
1968                                                                 fragmentShader <<
1969                                                                                 "\tcolor[" << compNdx << "] += " << (range[compNdx] / divider)
1970                                                                                 << " * bitfieldExtract(" << (nextSrcBit % 2 == 0 ? "x" : "y") << ", " << (nextSrcBit / 2) << ", 1);\n";
1971
1972                                                                 nextSrcBit++;
1973                                                                 dstBitsUsed[compNdx]++;
1974                                                         }
1975
1976                                                         divider *= 2;
1977                                                 }
1978                                         }
1979
1980                                         fragmentShader <<
1981                                                 "\to_color = uvec4(color[0], color[1], color[2], color[3]);\n"
1982                                                 "}\n";
1983
1984                                         dst.glslSources.add("quad-frag") << glu::FragmentSource(fragmentShader.str());
1985                                         break;
1986                                 }
1987
1988                                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
1989                                 {
1990                                         const UVec4     bits            (tcu::getTextureFormatBitDepth(format).cast<deUint32>());
1991                                         const IVec4 minValue    (0);
1992                                         const IVec4 range               ((UVec4(1u) << tcu::min(bits, UVec4(30))).cast<deInt32>());
1993                                         const IVec4 maxV                ((UVec4(1u) << (bits - UVec4(1u))).cast<deInt32>());
1994                                         const IVec4 clampMax    (maxV - 1);
1995                                         const IVec4 clampMin    (-maxV);
1996                                         std::ostringstream              fragmentShader;
1997
1998                                         fragmentShader <<
1999                                                 "#version 450\n"
2000                                                 "layout(location = 0) out highp ivec4 o_color;\n"
2001                                                 "layout(push_constant) uniform PushConstant {\n"
2002                                                 "\thighp uint sampleIndex;\n"
2003                                                 "} pushConstants;\n"
2004                                                 "void main (void)\n"
2005                                                 "{\n"
2006                                                 "\thighp uint sampleIndex = pushConstants.sampleIndex;\n"
2007                                                 "\tgl_SampleMask[0] = int(0x1u << sampleIndex);\n"
2008                                                 "\thighp int color[4];\n"
2009                                                 "\thighp uint x = sampleIndex ^ uint(gl_FragCoord.x);\n"
2010                                                 "\thighp uint y = sampleIndex ^ uint(gl_FragCoord.y);\n";
2011
2012                                         for (int ndx = 0; ndx < 4; ndx++)
2013                                                 fragmentShader << "\tcolor[" << ndx << "] = "  << minValue[ndx] << ";\n";
2014
2015                                         {
2016                                                 const int               componentCount  = tcu::getNumUsedChannels(format.order);
2017                                                 const deUint32  bitSize                 (bits[0] + bits[1] + bits[2] + bits[3]);
2018                                                 deUint32                dstBitsUsed[4]  = { 0u, 0u, 0u, 0u };
2019                                                 deUint32                nextSrcBit              = 0;
2020                                                 deUint32                divider                 = 2;
2021
2022                                                 // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
2023                                                 while (nextSrcBit < de::min(bitSize, 10u))
2024                                                 {
2025                                                         for (int compNdx = 0; compNdx < componentCount; compNdx++)
2026                                                         {
2027                                                                 if (dstBitsUsed[compNdx] > bits[compNdx])
2028                                                                         continue;
2029
2030                                                                 fragmentShader <<
2031                                                                                 "\tcolor[" << compNdx << "] += " << (range[compNdx] / divider)
2032                                                                                 << " * int(bitfieldExtract(" << (nextSrcBit % 2 == 0 ? "x" : "y") << ", " << (nextSrcBit / 2) << ", 1));\n";
2033
2034                                                                 nextSrcBit++;
2035                                                                 dstBitsUsed[compNdx]++;
2036                                                         }
2037
2038                                                         divider *= 2;
2039                                                 }
2040                                         }
2041
2042                                         // The spec doesn't define whether signed-integers are clamped on output,
2043                                         // so we'll clamp them explicitly to have well-defined outputs.
2044                                         fragmentShader <<
2045                                                 "\to_color = clamp(ivec4(color[0], color[1], color[2], color[3]), " <<
2046                                                 "ivec4" << clampMin << ", ivec4" << clampMax << ");\n" <<
2047                                                 "}\n";
2048
2049                                         dst.glslSources.add("quad-frag") << glu::FragmentSource(fragmentShader.str());
2050                                         break;
2051                                 }
2052
2053                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
2054                                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
2055                                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
2056                                 {
2057                                         const tcu::TextureFormatInfo    info                    (tcu::getTextureFormatInfo(format));
2058                                         const UVec4                                             bits                    (tcu::getTextureFormatMantissaBitDepth(format).cast<deUint32>());
2059                                         const Vec4                                              minLimit                (-65536.0);
2060                                         const Vec4                                              maxLimit                (65536.0);
2061                                         const Vec4                                              minValue                (tcu::max(info.valueMin, minLimit));
2062                                         const Vec4                                              range                   (tcu::min(info.valueMax, maxLimit) - minValue);
2063                                         std::ostringstream                              fragmentShader;
2064
2065                                         fragmentShader <<
2066                                                 "#version 450\n"
2067                                                 "layout(location = 0) out highp vec4 o_color;\n"
2068                                                 "layout(push_constant) uniform PushConstant {\n"
2069                                                 "\thighp uint sampleIndex;\n"
2070                                                 "} pushConstants;\n"
2071                                                 "void main (void)\n"
2072                                                 "{\n"
2073                                                 "\thighp uint sampleIndex = pushConstants.sampleIndex;\n"
2074                                                 "\tgl_SampleMask[0] = int(0x1u << sampleIndex);\n"
2075                                                 "\thighp float color[4];\n"
2076                                                 "\thighp uint x = sampleIndex ^ uint(gl_FragCoord.x);\n"
2077                                                 "\thighp uint y = sampleIndex ^ uint(gl_FragCoord.y);\n";
2078
2079                                         for (int ndx = 0; ndx < 4; ndx++)
2080                                                 fragmentShader << "\tcolor[" << ndx << "] = "  << minValue[ndx] << ";\n";
2081
2082                                         {
2083                                                 const int               componentCount  = tcu::getNumUsedChannels(format.order);
2084                                                 const deUint32  bitSize                 (bits[0] + bits[1] + bits[2] + bits[3]);
2085                                                 deUint32                dstBitsUsed[4]  = { 0u, 0u, 0u, 0u };
2086                                                 deUint32                nextSrcBit              = 0;
2087                                                 deUint32                divider                 = 2;
2088
2089                                                 // \note Limited to ten bits since the target is 32x32, so there are 10 input bits
2090                                                 while (nextSrcBit < de::min(bitSize, 10u))
2091                                                 {
2092                                                         for (int compNdx = 0; compNdx < componentCount; compNdx++)
2093                                                         {
2094                                                                 if (dstBitsUsed[compNdx] > bits[compNdx])
2095                                                                         continue;
2096
2097                                                                 fragmentShader <<
2098                                                                                 "\tcolor[" << compNdx << "] += " << (range[compNdx] / (float)divider)
2099                                                                                 << " * float(bitfieldExtract(" << (nextSrcBit % 2 == 0 ? "x" : "y") << ", " << (nextSrcBit / 2) << ", 1));\n";
2100
2101                                                                 nextSrcBit++;
2102                                                                 dstBitsUsed[compNdx]++;
2103                                                         }
2104
2105                                                         divider *= 2;
2106                                                 }
2107                                         }
2108
2109                                         fragmentShader <<
2110                                                 "\to_color = vec4(color[0], color[1], color[2], color[3]);\n"
2111                                                 "}\n";
2112
2113                                         dst.glslSources.add("quad-frag") << glu::FragmentSource(fragmentShader.str());
2114                                         break;
2115                                 }
2116
2117                                 default:
2118                                         DE_FATAL("Unknown channel class");
2119                         }
2120                 }
2121
2122                 if (tcu::hasDepthComponent(format.order) || tcu::hasStencilComponent(format.order))
2123                 {
2124                         std::ostringstream splitShader;
2125
2126                         splitShader <<
2127                                 "#version 450\n";
2128
2129                         if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
2130                         {
2131                                 splitShader << "layout(input_attachment_index = 0, set = 0, binding = 0) uniform highp subpassInputMS i_depth;\n"
2132                                                         << "layout(input_attachment_index = 0, set = 0, binding = 1) uniform highp usubpassInputMS i_stencil;\n";
2133                         }
2134                         else if (tcu::hasDepthComponent(format.order))
2135                                 splitShader << "layout(input_attachment_index = 0, set = 0, binding = 0) uniform highp subpassInputMS i_depth;\n";
2136                         else if (tcu::hasStencilComponent(format.order))
2137                                 splitShader << "layout(input_attachment_index = 0, set = 0, binding = 0) uniform highp usubpassInputMS i_stencil;\n";
2138
2139                         splitShader <<
2140                                 "layout(push_constant) uniform PushConstant {\n"
2141                                 "\thighp uint splitSubpassIndex;\n"
2142                                 "} pushConstants;\n";
2143
2144                         for (deUint32 attachmentNdx = 0; attachmentNdx < de::min((deUint32)MAX_COLOR_ATTACHMENT_COUNT, config.sampleCount); attachmentNdx++)
2145                         {
2146                                 if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
2147                                         splitShader << "layout(location = " << attachmentNdx << ") out highp vec2 o_color" << attachmentNdx << ";\n";
2148                                 else
2149                                         splitShader << "layout(location = " << attachmentNdx << ") out highp float o_color" << attachmentNdx << ";\n";
2150                         }
2151
2152                         splitShader <<
2153                                 "void main (void)\n"
2154                                 "{\n";
2155
2156                         for (deUint32 attachmentNdx = 0; attachmentNdx < de::min((deUint32)MAX_COLOR_ATTACHMENT_COUNT, config.sampleCount); attachmentNdx++)
2157                         {
2158                                 if (tcu::hasDepthComponent(format.order))
2159                                         splitShader << "\thighp float depth" << attachmentNdx << " = subpassLoad(i_depth, int(" << MAX_COLOR_ATTACHMENT_COUNT << " * pushConstants.splitSubpassIndex + " << attachmentNdx << "u)).x;\n";
2160
2161                                 if (tcu::hasStencilComponent(format.order))
2162                                         splitShader << "\thighp uint stencil" << attachmentNdx << " = subpassLoad(i_stencil, int(" << MAX_COLOR_ATTACHMENT_COUNT << " * pushConstants.splitSubpassIndex + " << attachmentNdx << "u)).x;\n";
2163
2164                                 if (tcu::hasDepthComponent(format.order) && tcu::hasStencilComponent(format.order))
2165                                         splitShader << "\to_color" << attachmentNdx << " = vec2(depth" << attachmentNdx << ", float(stencil" << attachmentNdx << "));\n";
2166                                 else if (tcu::hasDepthComponent(format.order))
2167                                         splitShader << "\to_color" << attachmentNdx << " = float(depth" << attachmentNdx << ");\n";
2168                                 else if (tcu::hasStencilComponent(format.order))
2169                                         splitShader << "\to_color" << attachmentNdx << " = float(stencil" << attachmentNdx << ");\n";
2170                         }
2171
2172                         splitShader <<
2173                                 "}\n";
2174
2175                         dst.glslSources.add("quad-split-frag") << glu::FragmentSource(splitShader.str());
2176                 }
2177                 else
2178                 {
2179                         std::string subpassType;
2180                         std::string outputType;
2181
2182                         switch (channelClass)
2183                         {
2184                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
2185                                         subpassType     = "usubpassInputMS";
2186                                         outputType      = "uvec4";
2187                                         break;
2188
2189                                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
2190                                         subpassType     = "isubpassInputMS";
2191                                         outputType      = "ivec4";
2192                                         break;
2193
2194                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
2195                                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
2196                                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
2197                                         subpassType     = "subpassInputMS";
2198                                         outputType      = "vec4";
2199                                         break;
2200
2201                                 default:
2202                                         DE_FATAL("Unknown channel class");
2203                         }
2204
2205                         std::ostringstream splitShader;
2206                         splitShader <<
2207                                 "#version 450\n"
2208                                 "layout(input_attachment_index = 0, set = 0, binding = 0) uniform highp " << subpassType << " i_color;\n"
2209                                 "layout(push_constant) uniform PushConstant {\n"
2210                                 "\thighp uint splitSubpassIndex;\n"
2211                                 "} pushConstants;\n";
2212
2213                         for (deUint32 attachmentNdx = 0; attachmentNdx < de::min((deUint32)MAX_COLOR_ATTACHMENT_COUNT, config.sampleCount); attachmentNdx++)
2214                                 splitShader << "layout(location = " << attachmentNdx << ") out highp " << outputType << " o_color" << attachmentNdx << ";\n";
2215
2216                         splitShader <<
2217                                 "void main (void)\n"
2218                                 "{\n";
2219
2220                         for (deUint32 attachmentNdx = 0; attachmentNdx < de::min((deUint32)MAX_COLOR_ATTACHMENT_COUNT, config.sampleCount); attachmentNdx++)
2221                                 splitShader << "\to_color" << attachmentNdx << " = subpassLoad(i_color, int(" << MAX_COLOR_ATTACHMENT_COUNT << " * pushConstants.splitSubpassIndex + " << attachmentNdx << "u));\n";
2222
2223                         splitShader <<
2224                                 "}\n";
2225
2226                         dst.glslSources.add("quad-split-frag") << glu::FragmentSource(splitShader.str());
2227                 }
2228         }
2229 };
2230
2231 std::string formatToName (VkFormat format)
2232 {
2233         const std::string       formatStr       = de::toString(format);
2234         const std::string       prefix          = "VK_FORMAT_";
2235
2236         DE_ASSERT(formatStr.substr(0, prefix.length()) == prefix);
2237
2238         return de::toLower(formatStr.substr(prefix.length()));
2239 }
2240
2241 void initTests (tcu::TestCaseGroup* group)
2242 {
2243         static const VkFormat   formats[]       =
2244         {
2245                 VK_FORMAT_R5G6B5_UNORM_PACK16,
2246                 VK_FORMAT_R8_UNORM,
2247                 VK_FORMAT_R8_SNORM,
2248                 VK_FORMAT_R8_UINT,
2249                 VK_FORMAT_R8_SINT,
2250                 VK_FORMAT_R8G8_UNORM,
2251                 VK_FORMAT_R8G8_SNORM,
2252                 VK_FORMAT_R8G8_UINT,
2253                 VK_FORMAT_R8G8_SINT,
2254                 VK_FORMAT_R8G8B8A8_UNORM,
2255                 VK_FORMAT_R8G8B8A8_SNORM,
2256                 VK_FORMAT_R8G8B8A8_UINT,
2257                 VK_FORMAT_R8G8B8A8_SINT,
2258                 VK_FORMAT_R8G8B8A8_SRGB,
2259                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
2260                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
2261                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
2262                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
2263                 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
2264                 VK_FORMAT_B8G8R8A8_UNORM,
2265                 VK_FORMAT_B8G8R8A8_SRGB,
2266                 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
2267                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
2268                 VK_FORMAT_A2B10G10R10_UINT_PACK32,
2269                 VK_FORMAT_R16_UNORM,
2270                 VK_FORMAT_R16_SNORM,
2271                 VK_FORMAT_R16_UINT,
2272                 VK_FORMAT_R16_SINT,
2273                 VK_FORMAT_R16_SFLOAT,
2274                 VK_FORMAT_R16G16_UNORM,
2275                 VK_FORMAT_R16G16_SNORM,
2276                 VK_FORMAT_R16G16_UINT,
2277                 VK_FORMAT_R16G16_SINT,
2278                 VK_FORMAT_R16G16_SFLOAT,
2279                 VK_FORMAT_R16G16B16A16_UNORM,
2280                 VK_FORMAT_R16G16B16A16_SNORM,
2281                 VK_FORMAT_R16G16B16A16_UINT,
2282                 VK_FORMAT_R16G16B16A16_SINT,
2283                 VK_FORMAT_R16G16B16A16_SFLOAT,
2284                 VK_FORMAT_R32_UINT,
2285                 VK_FORMAT_R32_SINT,
2286                 VK_FORMAT_R32_SFLOAT,
2287                 VK_FORMAT_R32G32_UINT,
2288                 VK_FORMAT_R32G32_SINT,
2289                 VK_FORMAT_R32G32_SFLOAT,
2290                 VK_FORMAT_R32G32B32A32_UINT,
2291                 VK_FORMAT_R32G32B32A32_SINT,
2292                 VK_FORMAT_R32G32B32A32_SFLOAT,
2293
2294                 VK_FORMAT_D16_UNORM,
2295                 VK_FORMAT_X8_D24_UNORM_PACK32,
2296                 VK_FORMAT_D32_SFLOAT,
2297                 VK_FORMAT_S8_UINT,
2298                 VK_FORMAT_D16_UNORM_S8_UINT,
2299                 VK_FORMAT_D24_UNORM_S8_UINT,
2300                 VK_FORMAT_D32_SFLOAT_S8_UINT
2301         };
2302         const deUint32                  sampleCounts[] =
2303         {
2304                 2u, 4u, 8u, 16u, 32u
2305         };
2306         tcu::TestContext&               testCtx         (group->getTestContext());
2307
2308         for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
2309         {
2310                 const VkFormat                                  format          (formats[formatNdx]);
2311                 const std::string                               formatName      (formatToName(format));
2312                 de::MovePtr<tcu::TestCaseGroup> formatGroup     (new tcu::TestCaseGroup(testCtx, formatName.c_str(), formatName.c_str()));
2313
2314                 for (size_t sampleCountNdx = 0; sampleCountNdx < DE_LENGTH_OF_ARRAY(sampleCounts); sampleCountNdx++)
2315                 {
2316                         const deUint32          sampleCount     (sampleCounts[sampleCountNdx]);
2317                         const std::string       testName        ("samples_" + de::toString(sampleCount));
2318
2319                         formatGroup->addChild(new InstanceFactory1<MultisampleRenderPassTestInstance, TestConfig, Programs>(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName.c_str(), testName.c_str(), TestConfig(format, sampleCount)));
2320                 }
2321
2322                 group->addChild(formatGroup.release());
2323         }
2324 }
2325
2326 } // anonymous
2327
2328 tcu::TestCaseGroup* createRenderPassMultisampleTests (tcu::TestContext& testCtx)
2329 {
2330         return createTestGroup(testCtx, "multisample", "Multisample render pass tests", initTests);
2331 }
2332
2333 } // vkt