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

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2018 The Khronos Group 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 VK_KHR_depth_stencil_resolve tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktRenderPassDepthStencilResolveTests.hpp"
  25 #include "vktRenderPassTestsUtil.hpp"
  26
  27 #include "vktTestCaseUtil.hpp"
  28 #include "vktTestGroupUtil.hpp"
  29
  30 #include "vkDefs.hpp"
  31 #include "vkDeviceUtil.hpp"
  32 #include "vkImageUtil.hpp"
  33 #include "vkMemUtil.hpp"
  34 #include "vkPlatform.hpp"
  35 #include "vkPrograms.hpp"
  36 #include "vkQueryUtil.hpp"
  37 #include "vkRef.hpp"
  38 #include "vkRefUtil.hpp"
  39 #include "vkTypeUtil.hpp"
  40 #include "vkCmdUtil.hpp"
  41 #include "vkObjUtil.hpp"
  42
  43 #include "tcuImageCompare.hpp"
  44 #include "tcuFormatUtil.hpp"
  45 #include "tcuResultCollector.hpp"
  46 #include "tcuTestLog.hpp"
  47 #include "tcuTextureUtil.hpp"
  48
  49 #include "deUniquePtr.hpp"
  50 #include "deSharedPtr.hpp"
  51 #include "deMath.h"
  52
  53 #include <limits>
  54 #include <map>
  55
  56 using namespace vk;
  57
  58 using tcu::Vec4;
  59 using tcu::TestLog;
  60
  61 typedef de::SharedPtr<vk::Unique<VkImage> >             VkImageSp;
  62 typedef de::SharedPtr<vk::Unique<VkImageView> > VkImageViewSp;
  63 typedef de::SharedPtr<vk::Unique<VkBuffer> >    VkBufferSp;
  64 typedef de::SharedPtr<vk::Unique<VkPipeline> >  VkPipelineSp;
  65 typedef de::SharedPtr<Allocation>                               AllocationSp;
  66
  67 namespace vkt
  68 {
  69 namespace
  70 {
  71
  72 using namespace renderpass;
  73
  74 template<typename T>
  75 de::SharedPtr<T> safeSharedPtr (T* ptr)
  76 {
  77         try
  78         {
  79                 return de::SharedPtr<T>(ptr);
  80         }
  81         catch (...)
  82         {
  83                 delete ptr;
  84                 throw;
  85         }
  86 }
  87
  88 enum VerifyBuffer
  89 {
  90         VB_DEPTH = 0,
  91         VB_STENCIL
  92 };
  93
  94 struct TestConfig
  95 {
  96         VkFormat                                        format;
  97         deUint32                                        width;
  98         deUint32                                        height;
  99         deUint32                                        imageLayers;
 100         deUint32                                        viewLayers;
 101         deUint32                                        resolveBaseLayer;
 102         VkRect2D                                        renderArea;
 103         VkImageAspectFlags                      aspectFlag;
 104         deUint32                                        sampleCount;
 105         VkResolveModeFlagBits           depthResolveMode;
 106         VkResolveModeFlagBits           stencilResolveMode;
 107         VerifyBuffer                            verifyBuffer;
 108         VkClearDepthStencilValue        clearValue;
 109         float                                           depthExpectedValue;
 110         deUint8                                         stencilExpectedValue;
 111         bool                                            separateDepthStencilLayouts;
 112         bool                                            unusedResolve;
 113         tcu::Maybe<VkFormat>            compatibleFormat;
 114 };
 115
 116 // Auxiliar class to group depth formats by compatibility in bit size and format. Note there is at most one alternative format for
 117 // each given format as of the time this comment is being written, and the alternative (compatible) format for a given format can
 118 // only remove aspects but not add them. That is, we cannot use a depth/stencil attachment to resolve a depth-only attachment.
 119 //
 120 // See:
 121 //      * VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03181
 122 //      * VUID-VkSubpassDescriptionDepthStencilResolve-pDepthStencilResolveAttachment-03182
 123 class DepthCompatibilityManager
 124 {
 125 public:
 126         DepthCompatibilityManager ()
 127                 : m_compatibleFormats()
 128         {
 129                 m_compatibleFormats[VK_FORMAT_D32_SFLOAT_S8_UINT]       = VK_FORMAT_D32_SFLOAT;
 130                 m_compatibleFormats[VK_FORMAT_D16_UNORM_S8_UINT]        = VK_FORMAT_D16_UNORM;
 131                 m_compatibleFormats[VK_FORMAT_D24_UNORM_S8_UINT]        = VK_FORMAT_X8_D24_UNORM_PACK32;
 132         }
 133
 134         VkFormat getAlternativeFormat (VkFormat format) const
 135         {
 136                 const auto itr = m_compatibleFormats.find(format);
 137                 if (itr != end(m_compatibleFormats))
 138                         return itr->second;
 139                 return VK_FORMAT_UNDEFINED;
 140         }
 141
 142 private:
 143         std::map<VkFormat, VkFormat> m_compatibleFormats;
 144 };
 145
 146 float get16bitDepthComponent(deUint8* pixelPtr)
 147 {
 148         deUint16* value = reinterpret_cast<deUint16*>(pixelPtr);
 149         return static_cast<float>(*value) / 65535.0f;
 150 }
 151
 152 float get24bitDepthComponent(deUint8* pixelPtr)
 153 {
 154         const bool littleEndian = (DE_ENDIANNESS == DE_LITTLE_ENDIAN);
 155         deUint32 value = (((deUint32)pixelPtr[0]) << (!littleEndian * 16u)) |
 156                                                 (((deUint32)pixelPtr[1]) <<  8u) |
 157                                                 (((deUint32)pixelPtr[2]) << ( littleEndian * 16u));
 158         return static_cast<float>(value) / 16777215.0f;
 159 }
 160
 161 float get32bitDepthComponent(deUint8* pixelPtr)
 162 {
 163         return *(reinterpret_cast<float*>(pixelPtr));
 164 }
 165
 166 class DepthStencilResolveTest : public TestInstance
 167 {
 168 public:
 169                                                                 DepthStencilResolveTest         (Context& context, TestConfig config);
 170         virtual                                         ~DepthStencilResolveTest        (void);
 171
 172         virtual tcu::TestStatus         iterate (void);
 173
 174 protected:
 175         bool                                            isFeaturesSupported                             (void);
 176         bool                                            isSupportedFormat                               (Context& context, VkFormat format) const;
 177         VkSampleCountFlagBits           sampleCountBitFromSampleCount   (deUint32 count) const;
 178
 179         VkImageSp                                       createImage                                             (deUint32 sampleCount, VkImageUsageFlags additionalUsage = 0u);
 180         AllocationSp                            createImageMemory                               (VkImageSp image);
 181         VkImageViewSp                           createImageView                                 (VkImageSp image, deUint32 baseArrayLayer);
 182         AllocationSp                            createBufferMemory                              (void);
 183         VkBufferSp                                      createBuffer                                    (void);
 184
 185         Move<VkRenderPass>                      createRenderPass                                (VkFormat vkformat);
 186         Move<VkRenderPass>                      createRenderPassCompatible              (void);
 187         Move<VkFramebuffer>                     createFramebuffer                               (VkRenderPass renderPass, VkImageViewSp multisampleImageView, VkImageViewSp singlesampleImageView);
 188         Move<VkPipelineLayout>          createRenderPipelineLayout              (void);
 189         Move<VkPipeline>                        createRenderPipeline                    (VkRenderPass renderPass, VkPipelineLayout renderPipelineLayout);
 190
 191         void                                            submit                                                  (void);
 192         bool                                            verifyDepth                                             (void);
 193         bool                                            verifyStencil                                   (void);
 194
 195 protected:
 196         const TestConfig                                m_config;
 197         const bool                                              m_featureSupported;
 198
 199         const InstanceInterface&                m_vki;
 200         const DeviceInterface&                  m_vkd;
 201         VkDevice                                                m_device;
 202         VkPhysicalDevice                                m_physicalDevice;
 203
 204         const Unique<VkCommandPool>             m_commandPool;
 205
 206         VkImageSp                                               m_multisampleImage;
 207         AllocationSp                                    m_multisampleImageMemory;
 208         VkImageViewSp                                   m_multisampleImageView;
 209         VkImageSp                                               m_singlesampleImage;
 210         AllocationSp                                    m_singlesampleImageMemory;
 211         VkImageViewSp                                   m_singlesampleImageView;
 212         VkBufferSp                                              m_buffer;
 213         AllocationSp                                    m_bufferMemory;
 214
 215         Unique<VkRenderPass>                    m_renderPass;
 216         Unique<VkRenderPass>                    m_renderPassCompatible;
 217         Unique<VkFramebuffer>                   m_framebuffer;
 218         Unique<VkPipelineLayout>                m_renderPipelineLayout;
 219         Unique<VkPipeline>                              m_renderPipeline;
 220 };
 221
 222 DepthStencilResolveTest::DepthStencilResolveTest (Context& context, TestConfig config)
 223         : TestInstance                          (context)
 224         , m_config                                      (config)
 225         , m_featureSupported            (isFeaturesSupported())
 226         , m_vki                                         (context.getInstanceInterface())
 227         , m_vkd                                         (context.getDeviceInterface())
 228         , m_device                                      (context.getDevice())
 229         , m_physicalDevice                      (context.getPhysicalDevice())
 230
 231         , m_commandPool                         (createCommandPool(context.getDeviceInterface(), context.getDevice(), VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, context.getUniversalQueueFamilyIndex()))
 232
 233         , m_multisampleImage            (createImage(m_config.sampleCount, VK_IMAGE_USAGE_TRANSFER_SRC_BIT))
 234         , m_multisampleImageMemory      (createImageMemory(m_multisampleImage))
 235         , m_multisampleImageView        (createImageView(m_multisampleImage, 0u))
 236
 237         , m_singlesampleImage           (createImage(1, (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | (config.unusedResolve ? static_cast<vk::VkImageUsageFlags>(VK_IMAGE_USAGE_TRANSFER_DST_BIT) : 0u))))
 238         , m_singlesampleImageMemory     (createImageMemory(m_singlesampleImage))
 239         , m_singlesampleImageView       (createImageView(m_singlesampleImage, m_config.resolveBaseLayer))
 240
 241         , m_buffer                                      (createBuffer())
 242         , m_bufferMemory                        (createBufferMemory())
 243
 244         , m_renderPass                          (createRenderPass(m_config.format))
 245         , m_renderPassCompatible        (createRenderPassCompatible())
 246         , m_framebuffer                         (createFramebuffer(*m_renderPass, m_multisampleImageView, m_singlesampleImageView))
 247         , m_renderPipelineLayout        (createRenderPipelineLayout())
 248         , m_renderPipeline                      (createRenderPipeline(*m_renderPass, *m_renderPipelineLayout))
 249 {
 250 }
 251
 252 DepthStencilResolveTest::~DepthStencilResolveTest (void)
 253 {
 254 }
 255
 256 bool DepthStencilResolveTest::isFeaturesSupported()
 257 {
 258         m_context.requireDeviceFunctionality("VK_KHR_depth_stencil_resolve");
 259         if (m_config.imageLayers > 1)
 260                 m_context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
 261
 262         if (m_config.separateDepthStencilLayouts)
 263                 m_context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
 264
 265         VkPhysicalDeviceDepthStencilResolveProperties dsResolveProperties;
 266         deMemset(&dsResolveProperties, 0, sizeof(VkPhysicalDeviceDepthStencilResolveProperties));
 267         dsResolveProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
 268         dsResolveProperties.pNext = DE_NULL;
 269
 270         VkPhysicalDeviceProperties2 deviceProperties;
 271         deviceProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
 272         deviceProperties.pNext = &dsResolveProperties;
 273
 274         // perform query to get supported float control properties
 275         const VkPhysicalDevice                  physicalDevice          = m_context.getPhysicalDevice();
 276         const vk::InstanceInterface&    instanceInterface       = m_context.getInstanceInterface();
 277         instanceInterface.getPhysicalDeviceProperties2(physicalDevice, &deviceProperties);
 278
 279         // check if both modes are supported
 280         VkResolveModeFlagBits depthResolveMode          = m_config.depthResolveMode;
 281         VkResolveModeFlagBits stencilResolveMode        = m_config.stencilResolveMode;
 282
 283         if ((depthResolveMode != VK_RESOLVE_MODE_NONE) &&
 284                 !(depthResolveMode & dsResolveProperties.supportedDepthResolveModes))
 285                 TCU_THROW(NotSupportedError, "Depth resolve mode not supported");
 286
 287         if ((stencilResolveMode != VK_RESOLVE_MODE_NONE) &&
 288                 !(stencilResolveMode & dsResolveProperties.supportedStencilResolveModes))
 289                 TCU_THROW(NotSupportedError, "Stencil resolve mode not supported");
 290
 291         // check if the implementation supports setting the depth and stencil resolve
 292         // modes to different values when one of those modes is VK_RESOLVE_MODE_NONE
 293         if (dsResolveProperties.independentResolveNone)
 294         {
 295                 if ((!dsResolveProperties.independentResolve) &&
 296                         (depthResolveMode != stencilResolveMode) &&
 297                         (depthResolveMode != VK_RESOLVE_MODE_NONE) &&
 298                         (stencilResolveMode != VK_RESOLVE_MODE_NONE))
 299                         TCU_THROW(NotSupportedError, "Implementation doesn't support diferent resolve modes");
 300         }
 301         else if (!dsResolveProperties.independentResolve && (depthResolveMode != stencilResolveMode))
 302         {
 303                 // when independentResolveNone and independentResolve are VK_FALSE then both modes must be the same
 304                 TCU_THROW(NotSupportedError, "Implementation doesn't support diferent resolve modes");
 305         }
 306
 307         // Check alternative format support if needed.
 308         if (m_config.compatibleFormat)
 309         {
 310                 if (! isSupportedFormat(m_context, m_config.compatibleFormat.get()))
 311                         TCU_THROW(NotSupportedError, "Alternative image format for compatibility test not supported");
 312         }
 313
 314         return true;
 315 }
 316
 317 VkSampleCountFlagBits DepthStencilResolveTest::sampleCountBitFromSampleCount (deUint32 count) const
 318 {
 319         switch (count)
 320         {
 321                 case 1:  return VK_SAMPLE_COUNT_1_BIT;
 322                 case 2:  return VK_SAMPLE_COUNT_2_BIT;
 323                 case 4:  return VK_SAMPLE_COUNT_4_BIT;
 324                 case 8:  return VK_SAMPLE_COUNT_8_BIT;
 325                 case 16: return VK_SAMPLE_COUNT_16_BIT;
 326                 case 32: return VK_SAMPLE_COUNT_32_BIT;
 327                 case 64: return VK_SAMPLE_COUNT_64_BIT;
 328
 329                 default:
 330                         DE_FATAL("Invalid sample count");
 331                         return (VkSampleCountFlagBits)0x0;
 332         }
 333 }
 334
 335 VkImageSp DepthStencilResolveTest::createImage (deUint32 sampleCount, VkImageUsageFlags additionalUsage)
 336 {
 337         const tcu::TextureFormat        format(mapVkFormat(m_config.format));
 338         const VkImageTiling                     imageTiling(VK_IMAGE_TILING_OPTIMAL);
 339         VkSampleCountFlagBits           sampleCountBit(sampleCountBitFromSampleCount(sampleCount));
 340         VkImageUsageFlags                       usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | additionalUsage;
 341
 342         VkImageFormatProperties imageFormatProperties;
 343         if (m_vki.getPhysicalDeviceImageFormatProperties(m_physicalDevice, m_config.format, VK_IMAGE_TYPE_2D, imageTiling,
 344                                                                                                          usage, 0u, &imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
 345         {
 346                 TCU_THROW(NotSupportedError, "Format not supported");
 347         }
 348         if (imageFormatProperties.sampleCounts < sampleCount)
 349         {
 350                 TCU_THROW(NotSupportedError, "Sample count not supported");
 351         }
 352         if (imageFormatProperties.maxArrayLayers < m_config.imageLayers)
 353         {
 354                 TCU_THROW(NotSupportedError, "Layers count not supported");
 355         }
 356
 357         const VkExtent3D imageExtent =
 358         {
 359                 m_config.width,
 360                 m_config.height,
 361                 1u
 362         };
 363
 364         if (!(tcu::hasDepthComponent(format.order) || tcu::hasStencilComponent(format.order)))
 365                 TCU_THROW(NotSupportedError, "Format can't be used as depth/stencil attachment");
 366
 367         if (imageFormatProperties.maxExtent.width < imageExtent.width
 368                 || imageFormatProperties.maxExtent.height < imageExtent.height
 369                 || ((imageFormatProperties.sampleCounts & sampleCountBit) == 0)
 370                 || imageFormatProperties.maxArrayLayers < m_config.imageLayers)
 371         {
 372                 TCU_THROW(NotSupportedError, "Image type not supported");
 373         }
 374
 375         const VkImageCreateInfo pCreateInfo =
 376         {
 377                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
 378                 DE_NULL,
 379                 0u,
 380                 VK_IMAGE_TYPE_2D,
 381                 m_config.format,
 382                 imageExtent,
 383                 1u,
 384                 m_config.imageLayers,
 385                 sampleCountBit,
 386                 imageTiling,
 387                 usage,
 388                 VK_SHARING_MODE_EXCLUSIVE,
 389                 0u,
 390                 DE_NULL,
 391                 VK_IMAGE_LAYOUT_UNDEFINED
 392         };
 393
 394         return safeSharedPtr(new Unique<VkImage>(vk::createImage(m_vkd, m_device, &pCreateInfo)));
 395 }
 396
 397 AllocationSp DepthStencilResolveTest::createImageMemory (VkImageSp image)
 398 {
 399         Allocator& allocator = m_context.getDefaultAllocator();
 400
 401         de::MovePtr<Allocation> allocation (allocator.allocate(getImageMemoryRequirements(m_vkd, m_device, **image), MemoryRequirement::Any));
 402         VK_CHECK(m_vkd.bindImageMemory(m_device, **image, allocation->getMemory(), allocation->getOffset()));
 403         return safeSharedPtr(allocation.release());
 404 }
 405
 406 VkImageViewSp DepthStencilResolveTest::createImageView (VkImageSp image, deUint32 baseArrayLayer)
 407 {
 408         const VkImageSubresourceRange range =
 409         {
 410                 m_config.aspectFlag,
 411                 0u,
 412                 1u,
 413                 baseArrayLayer,
 414                 m_config.viewLayers
 415         };
 416
 417         const VkImageViewCreateInfo pCreateInfo =
 418         {
 419                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
 420                 DE_NULL,
 421                 0u,
 422                 **image,
 423                 (m_config.viewLayers > 1) ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D,
 424                 m_config.format,
 425                 makeComponentMappingRGBA(),
 426                 range,
 427         };
 428         return safeSharedPtr(new Unique<VkImageView>(vk::createImageView(m_vkd, m_device, &pCreateInfo)));
 429 }
 430
 431 Move<VkRenderPass> DepthStencilResolveTest::createRenderPass (VkFormat vkformat)
 432 {
 433         // When the depth/stencil resolve attachment is unused, it needs to be cleared outside the render pass so it has the expected values.
 434         if (m_config.unusedResolve)
 435         {
 436                 const tcu::TextureFormat                        format                  (mapVkFormat(vkformat));
 437                 const Unique<VkCommandBuffer>           commandBuffer   (allocateCommandBuffer(m_vkd, m_device, *m_commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 438                 const vk::VkImageSubresourceRange       imageRange              =
 439                 {
 440                         ((tcu::hasDepthComponent(format.order)          ? static_cast<vk::VkImageAspectFlags>(vk::VK_IMAGE_ASPECT_DEPTH_BIT)    : 0u) |
 441                          (tcu::hasStencilComponent(format.order)        ? static_cast<vk::VkImageAspectFlags>(vk::VK_IMAGE_ASPECT_STENCIL_BIT)  : 0u)),
 442                         0u,
 443                         VK_REMAINING_MIP_LEVELS,
 444                         0u,
 445                         VK_REMAINING_ARRAY_LAYERS,
 446                 };
 447                 const vk::VkImageMemoryBarrier          preBarrier              =
 448                 {
 449                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 450                         nullptr,
 451
 452                         // src and dst access masks.
 453                         0,
 454                         vk::VK_ACCESS_TRANSFER_WRITE_BIT,
 455
 456                         // old and new layouts.
 457                         vk::VK_IMAGE_LAYOUT_UNDEFINED,
 458                         vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 459
 460                         VK_QUEUE_FAMILY_IGNORED,
 461                         VK_QUEUE_FAMILY_IGNORED,
 462
 463                         **m_singlesampleImage,
 464                         imageRange,
 465                 };
 466                 const vk::VkImageMemoryBarrier          postBarrier             =
 467                 {
 468                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 469                         nullptr,
 470
 471                         // src and dst access masks.
 472                         vk::VK_ACCESS_TRANSFER_WRITE_BIT,
 473                         0,
 474
 475                         // old and new layouts.
 476                         vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 477                         vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 478
 479                         VK_QUEUE_FAMILY_IGNORED,
 480                         VK_QUEUE_FAMILY_IGNORED,
 481
 482                         **m_singlesampleImage,
 483                         imageRange,
 484                 };
 485
 486                 vk::beginCommandBuffer(m_vkd, commandBuffer.get());
 487                         m_vkd.cmdPipelineBarrier(commandBuffer.get(), vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &preBarrier);
 488                         m_vkd.cmdClearDepthStencilImage(commandBuffer.get(), **m_singlesampleImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_config.clearValue, 1u, &imageRange);
 489                         m_vkd.cmdPipelineBarrier(commandBuffer.get(), vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &postBarrier);
 490                 vk::endCommandBuffer(m_vkd, commandBuffer.get());
 491
 492                 vk::submitCommandsAndWait(m_vkd, m_device, m_context.getUniversalQueue(), commandBuffer.get());
 493         }
 494
 495         const VkSampleCountFlagBits samples(sampleCountBitFromSampleCount(m_config.sampleCount));
 496
 497         VkImageLayout layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 498         VkAttachmentReferenceStencilLayoutKHR stencilLayout =
 499         {
 500                 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR,
 501                 DE_NULL,
 502                 VK_IMAGE_LAYOUT_UNDEFINED,
 503         };
 504         void * attachmentRefStencil = DE_NULL;
 505         VkImageLayout finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
 506         VkAttachmentDescriptionStencilLayoutKHR stencilFinalLayout =
 507         {
 508                 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
 509                 DE_NULL,
 510                 VK_IMAGE_LAYOUT_UNDEFINED,
 511                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 512         };
 513         void * attachmentDescriptionStencil = DE_NULL;
 514
 515         if (m_config.separateDepthStencilLayouts)
 516         {
 517                 if (m_config.verifyBuffer == VB_DEPTH)
 518                 {
 519                         layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
 520                         stencilLayout.stencilLayout = VK_IMAGE_LAYOUT_GENERAL;
 521                         finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
 522                         stencilFinalLayout.stencilFinalLayout = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR; // This aspect should be unused.
 523                 }
 524                 else
 525                 {
 526                         layout = VK_IMAGE_LAYOUT_GENERAL;
 527                         stencilLayout.stencilLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
 528                         finalLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR; // This aspect should be unused.
 529                         stencilFinalLayout.stencilFinalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
 530                 }
 531                 attachmentRefStencil = &stencilLayout;
 532                 attachmentDescriptionStencil = &stencilFinalLayout;
 533         }
 534
 535         const AttachmentDescription2 multisampleAttachment              // VkAttachmentDescription2
 536         (
 537                                                                                                                         // VkStructureType                                      sType;
 538                 attachmentDescriptionStencil,                                           // const void*                                          pNext;
 539                 0u,                                                                                                     // VkAttachmentDescriptionFlags         flags;
 540                 m_config.format,                                                                        // VkFormat                                                     format;
 541                 samples,                                                                                        // VkSampleCountFlagBits                        samples;
 542                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 543                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                                       // VkAttachmentStoreOp                          storeOp;
 544                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           stencilLoadOp;
 545                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                                       // VkAttachmentStoreOp                          stencilStoreOp;
 546                 VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                                        initialLayout;
 547                 finalLayout                                                                                     // VkImageLayout                                        finalLayout;
 548         );
 549         const AttachmentReference2 multisampleAttachmentRef             // VkAttachmentReference2
 550         (
 551                                                                                                                         // VkStructureType                                      sType;
 552                 attachmentRefStencil,                                                           // const void*                                          pNext;
 553                 0u,                                                                                                     // deUint32                                                     attachment;
 554                 layout,                                                                                         // VkImageLayout                                        layout;
 555                 m_config.aspectFlag                                                                     // VkImageAspectFlags                           aspectMask;
 556         );
 557
 558         const vk::VkImageLayout         singleSampleInitialLayout = (m_config.unusedResolve ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED);
 559
 560
 561         const tcu::TextureFormat                        format                  (mapVkFormat(vkformat));
 562         VkImageAspectFlags aspectFlags =
 563                 ((tcu::hasDepthComponent(format.order)          ? static_cast<vk::VkImageAspectFlags>(vk::VK_IMAGE_ASPECT_DEPTH_BIT)    : 0u) |
 564                  (tcu::hasStencilComponent(format.order)        ? static_cast<vk::VkImageAspectFlags>(vk::VK_IMAGE_ASPECT_STENCIL_BIT)  : 0u));
 565
 566         const AttachmentDescription2 singlesampleAttachment             // VkAttachmentDescription2
 567         (
 568                                                                                                                         // VkStructureType                                      sType;
 569                 attachmentDescriptionStencil,                                           // const void*                                          pNext;
 570                 0u,                                                                                                     // VkAttachmentDescriptionFlags         flags;
 571                 vkformat,                                                                                       // VkFormat                                                     format;
 572                 VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 573                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 574                 VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 575                 VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           stencilLoadOp;
 576                 VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          stencilStoreOp;
 577                 singleSampleInitialLayout,                                                      // VkImageLayout                                        initialLayout;
 578                 finalLayout                                                                                     // VkImageLayout                                        finalLayout;
 579         );
 580         AttachmentReference2 singlesampleAttachmentRef                  // VkAttachmentReference2
 581         (
 582                                                                                                                                 // VkStructureType                                      sType;
 583                 DE_NULL,                                                                                                // const void*                                          pNext;
 584                 (m_config.unusedResolve ? VK_ATTACHMENT_UNUSED : 1u),   // deUint32                                                     attachment;
 585                 layout,                                                                                                 // VkImageLayout                                        layout;
 586                 aspectFlags                                                                                             // VkImageAspectFlags                           aspectMask;
 587         );
 588
 589         std::vector<AttachmentDescription2> attachments;
 590         attachments.push_back(multisampleAttachment);
 591         attachments.push_back(singlesampleAttachment);
 592
 593         VkSubpassDescriptionDepthStencilResolve dsResolveDescription =
 594         {
 595                 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
 596                 DE_NULL,                                                                                                                                // const void*                                          pNext;
 597                 m_config.depthResolveMode,                                                                                              // VkResolveModeFlagBits                        depthResolveMode;
 598                 m_config.stencilResolveMode,                                                                                    // VkResolveModeFlagBits                        stencilResolveMode;
 599                 &singlesampleAttachmentRef                                                                                              // VkAttachmentReference2                       pDepthStencilResolveAttachment;
 600         };
 601
 602         const SubpassDescription2 subpass                                       // VkSubpassDescription2
 603         (
 604                                                                                                                 // VkStructureType                                              sType;
 605                 &dsResolveDescription,                                                  // const void*                                                  pNext;
 606                 (VkSubpassDescriptionFlags)0,                                   // VkSubpassDescriptionFlags                    flags;
 607                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                // VkPipelineBindPoint                                  pipelineBindPoint;
 608                 0u,                                                                                             // deUint32                                                             viewMask;
 609                 0u,                                                                                             // deUint32                                                             inputAttachmentCount;
 610                 DE_NULL,                                                                                // const VkAttachmentReference2*                pInputAttachments;
 611                 0u,                                                                                             // deUint32                                                             colorAttachmentCount;
 612                 DE_NULL,                                                                                // const VkAttachmentReference2*                pColorAttachments;
 613                 DE_NULL,                                                                                // const VkAttachmentReference2*                pResolveAttachments;
 614                 &multisampleAttachmentRef,                                              // const VkAttachmentReference2*                pDepthStencilAttachment;
 615                 0u,                                                                                             // deUint32                                                             preserveAttachmentCount;
 616                 DE_NULL                                                                                 // const deUint32*                                              pPreserveAttachments;
 617         );
 618
 619         const RenderPassCreateInfo2 renderPassCreator           // VkRenderPassCreateInfo2
 620         (
 621                                                                                                                 // VkStructureType                                              sType;
 622                 DE_NULL,                                                                                // const void*                                                  pNext;
 623                 (VkRenderPassCreateFlags)0u,                                    // VkRenderPassCreateFlags                              flags;
 624                 (deUint32)attachments.size(),                                   // deUint32                                                             attachmentCount;
 625                 &attachments[0],                                                                // const VkAttachmentDescription2*              pAttachments;
 626                 1u,                                                                                             // deUint32                                                             subpassCount;
 627                 &subpass,                                                                               // const VkSubpassDescription2*                 pSubpasses;
 628                 0u,                                                                                             // deUint32                                                             dependencyCount;
 629                 DE_NULL,                                                                                // const VkSubpassDependency2*                  pDependencies;
 630                 0u,                                                                                             // deUint32                                                             correlatedViewMaskCount;
 631                 DE_NULL                                                                                 // const deUint32*                                              pCorrelatedViewMasks;
 632         );
 633
 634         return renderPassCreator.createRenderPass(m_vkd, m_device);
 635 }
 636
 637 // Checks format support.
 638 // Note: we need the context because this is called from the constructor only after m_config has been set.
 639 bool DepthStencilResolveTest::isSupportedFormat (Context& context, VkFormat format) const
 640 {
 641         const VkImageUsageFlags usage   = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
 642                                                                         | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
 643                                                                         | (m_config.unusedResolve ? VK_IMAGE_USAGE_TRANSFER_DST_BIT : static_cast<vk::VkImageUsageFlagBits>(0u));
 644         VkImageFormatProperties props;
 645
 646         const auto&     vki                             = context.getInstanceInterface();
 647         const auto      physicalDevice  = context.getPhysicalDevice();
 648         const auto      formatCheck             = vki.getPhysicalDeviceImageFormatProperties(physicalDevice, format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, usage, 0u, &props);
 649
 650         return (formatCheck == VK_SUCCESS);
 651 }
 652
 653 Move<VkRenderPass> DepthStencilResolveTest::createRenderPassCompatible (void)
 654 {
 655         // Early exit if we are not testing compatibility.
 656         if (! m_config.compatibleFormat)
 657                 return {};
 658
 659         return createRenderPass(m_config.compatibleFormat.get());
 660 }
 661
 662 Move<VkFramebuffer> DepthStencilResolveTest::createFramebuffer (VkRenderPass renderPass, VkImageViewSp multisampleImageView, VkImageViewSp singlesampleImageView)
 663 {
 664         std::vector<VkImageView> attachments;
 665         attachments.push_back(**multisampleImageView);
 666         attachments.push_back(**singlesampleImageView);
 667
 668         const VkFramebufferCreateInfo createInfo =
 669         {
 670                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
 671                 DE_NULL,
 672                 0u,
 673
 674                 renderPass,
 675                 (deUint32)attachments.size(),
 676                 &attachments[0],
 677
 678                 m_config.width,
 679                 m_config.height,
 680                 m_config.viewLayers
 681         };
 682
 683         return vk::createFramebuffer(m_vkd, m_device, &createInfo);
 684 }
 685
 686 Move<VkPipelineLayout> DepthStencilResolveTest::createRenderPipelineLayout (void)
 687 {
 688         VkPushConstantRange pushConstant =
 689         {
 690                 VK_SHADER_STAGE_FRAGMENT_BIT,
 691                 0u,
 692                 4u
 693         };
 694
 695         deUint32                                pushConstantRangeCount  = 0u;
 696         VkPushConstantRange*    pPushConstantRanges             = DE_NULL;
 697         if (m_config.verifyBuffer == VB_STENCIL)
 698         {
 699                 pushConstantRangeCount  = 1u;
 700                 pPushConstantRanges             = &pushConstant;
 701         }
 702
 703         const VkPipelineLayoutCreateInfo createInfo     =
 704         {
 705                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
 706                 DE_NULL,
 707                 (vk::VkPipelineLayoutCreateFlags)0,
 708
 709                 0u,
 710                 DE_NULL,
 711
 712                 pushConstantRangeCount,
 713                 pPushConstantRanges
 714         };
 715
 716         return vk::createPipelineLayout(m_vkd, m_device, &createInfo);
 717 }
 718
 719 Move<VkPipeline> DepthStencilResolveTest::createRenderPipeline (VkRenderPass renderPass, VkPipelineLayout renderPipelineLayout)
 720 {
 721         const bool testingStencil = (m_config.verifyBuffer == VB_STENCIL);
 722         const vk::BinaryCollection& binaryCollection = m_context.getBinaryCollection();
 723
 724         const Unique<VkShaderModule>    vertexShaderModule              (createShaderModule(m_vkd, m_device, binaryCollection.get("quad-vert"), 0u));
 725         const Unique<VkShaderModule>    fragmentShaderModule    (createShaderModule(m_vkd, m_device, binaryCollection.get("quad-frag"), 0u));
 726         const Move<VkShaderModule>              geometryShaderModule    (m_config.imageLayers == 1 ? Move<VkShaderModule>() : createShaderModule(m_vkd, m_device, binaryCollection.get("quad-geom"), 0u));
 727
 728         const VkPipelineVertexInputStateCreateInfo vertexInputState =
 729         {
 730                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
 731                 DE_NULL,
 732                 (VkPipelineVertexInputStateCreateFlags)0u,
 733
 734                 0u,
 735                 DE_NULL,
 736
 737                 0u,
 738                 DE_NULL
 739         };
 740         const tcu::UVec2                                view            (m_config.width, m_config.height);
 741         const std::vector<VkViewport>   viewports       (1, makeViewport(view));
 742         const std::vector<VkRect2D>             scissors        (1, m_config.renderArea);
 743
 744         const VkPipelineMultisampleStateCreateInfo multisampleState =
 745         {
 746                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
 747                 DE_NULL,
 748                 (VkPipelineMultisampleStateCreateFlags)0u,
 749
 750                 sampleCountBitFromSampleCount(m_config.sampleCount),
 751                 VK_FALSE,
 752                 0.0f,
 753                 DE_NULL,
 754                 VK_FALSE,
 755                 VK_FALSE,
 756         };
 757         const VkPipelineDepthStencilStateCreateInfo depthStencilState =
 758         {
 759                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
 760                 DE_NULL,
 761                 (VkPipelineDepthStencilStateCreateFlags)0u,
 762
 763                 VK_TRUE,                                                        // depthTestEnable
 764                 VK_TRUE,
 765                 VK_COMPARE_OP_ALWAYS,
 766                 VK_FALSE,
 767                 testingStencil,                                         // stencilTestEnable
 768                 {
 769                         VK_STENCIL_OP_REPLACE,                  // failOp
 770                         VK_STENCIL_OP_REPLACE,                  // passOp
 771                         VK_STENCIL_OP_REPLACE,                  // depthFailOp
 772                         VK_COMPARE_OP_ALWAYS,                   // compareOp
 773                         0xFFu,                                                  // compareMask
 774                         0xFFu,                                                  // writeMask
 775                         1                                                               // reference
 776                 },
 777                 {
 778                         VK_STENCIL_OP_REPLACE,
 779                         VK_STENCIL_OP_REPLACE,
 780                         VK_STENCIL_OP_REPLACE,
 781                         VK_COMPARE_OP_ALWAYS,
 782                         0xFFu,
 783                         0xFFu,
 784                         1
 785                 },
 786                 0.0f,
 787                 1.0f
 788         };
 789
 790         std::vector<VkDynamicState> dynamicState;
 791         dynamicState.push_back(VK_DYNAMIC_STATE_STENCIL_REFERENCE);
 792         const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
 793         {
 794                 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,   // VkStructureType                      sType;
 795                 DE_NULL,                                                                                                // const void*                          pNext;
 796                 (VkPipelineDynamicStateCreateFlags)0u,                                  // VkPipelineDynamicStateCreateFlags    flags;
 797                 static_cast<deUint32>(dynamicState.size()),                             // deUint32                             dynamicStateCount;
 798                 &dynamicState[0]                                                                                // const VkDynamicState*                pDynamicStates;
 799         };
 800
 801         return makeGraphicsPipeline(m_vkd,                                                                                                                      // const DeviceInterface&                        vk
 802                                                                 m_device,                                                                                                               // const VkDevice                                device
 803                                                                 renderPipelineLayout,                                                                                   // const VkPipelineLayout                        pipelineLayout
 804                                                                 *vertexShaderModule,                                                                                    // const VkShaderModule                          vertexShaderModule
 805                                                                 DE_NULL,                                                                                                                // const VkShaderModule                          tessellationControlShaderModule
 806                                                                 DE_NULL,                                                                                                                // const VkShaderModule                          tessellationEvalShaderModule
 807                                                                 m_config.imageLayers == 1 ? DE_NULL : *geometryShaderModule,    // const VkShaderModule                          geometryShaderModule
 808                                                                 *fragmentShaderModule,                                                                                  // const VkShaderModule                          fragmentShaderModule
 809                                                                 renderPass,                                                                                                             // const VkRenderPass                            renderPass
 810                                                                 viewports,                                                                                                              // const std::vector<VkViewport>&                viewports
 811                                                                 scissors,                                                                                                               // const std::vector<VkRect2D>&                  scissors
 812                                                                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                                                    // const VkPrimitiveTopology                     topology
 813                                                                 0u,                                                                                                                             // const deUint32                                subpass
 814                                                                 0u,                                                                                                                             // const deUint32                                patchControlPoints
 815                                                                 &vertexInputState,                                                                                              // const VkPipelineVertexInputStateCreateInfo*   vertexInputStateCreateInfo
 816                                                                 DE_NULL,                                                                                                                // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
 817                                                                 &multisampleState,                                                                                              // const VkPipelineMultisampleStateCreateInfo*   multisampleStateCreateInfo
 818                                                                 &depthStencilState,                                                                                             // const VkPipelineDepthStencilStateCreateInfo*  depthStencilStateCreateInfo
 819                                                                 DE_NULL,                                                                                                                // const VkPipelineColorBlendStateCreateInfo*    colorBlendStateCreateInfo
 820                                                                 testingStencil ? &dynamicStateCreateInfo : DE_NULL);                    // const VkPipelineDynamicStateCreateInfo*       dynamicStateCreateInfo
 821 }
 822
 823 AllocationSp DepthStencilResolveTest::createBufferMemory (void)
 824 {
 825         Allocator&                              allocator = m_context.getDefaultAllocator();
 826         de::MovePtr<Allocation> allocation(allocator.allocate(getBufferMemoryRequirements(m_vkd, m_device, **m_buffer), MemoryRequirement::HostVisible));
 827         VK_CHECK(m_vkd.bindBufferMemory(m_device, **m_buffer, allocation->getMemory(), allocation->getOffset()));
 828         return safeSharedPtr(allocation.release());
 829 }
 830
 831 VkBufferSp DepthStencilResolveTest::createBuffer (void)
 832 {
 833         const VkBufferUsageFlags        bufferUsage                     (VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 834         const tcu::TextureFormat        textureFormat           (mapVkFormat(m_config.format));
 835         const VkDeviceSize                      pixelSize                       (textureFormat.getPixelSize());
 836         const VkBufferCreateInfo        createInfo                      =
 837         {
 838                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
 839                 DE_NULL,
 840                 0u,
 841
 842                 m_config.width * m_config.height * m_config.imageLayers * pixelSize,
 843                 bufferUsage,
 844
 845                 VK_SHARING_MODE_EXCLUSIVE,
 846                 0u,
 847                 DE_NULL
 848         };
 849         return safeSharedPtr(new Unique<VkBuffer>(vk::createBuffer(m_vkd, m_device, &createInfo)));
 850 }
 851
 852 void DepthStencilResolveTest::submit (void)
 853 {
 854         const DeviceInterface&                                          vkd                                     (m_context.getDeviceInterface());
 855         const VkDevice                                                          device                          (m_context.getDevice());
 856         const Unique<VkCommandBuffer>                           commandBuffer           (allocateCommandBuffer(vkd, device, *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 857         const RenderpassSubpass2::SubpassBeginInfo      subpassBeginInfo        (DE_NULL, VK_SUBPASS_CONTENTS_INLINE);
 858         const RenderpassSubpass2::SubpassEndInfo        subpassEndInfo          (DE_NULL);
 859
 860         beginCommandBuffer(vkd, *commandBuffer);
 861
 862         {
 863                 VkClearValue clearValues[2];
 864                 clearValues[0].depthStencil = m_config.clearValue;
 865                 clearValues[1].depthStencil = m_config.clearValue;
 866
 867                 const VkRenderPassBeginInfo beginInfo =
 868                 {
 869                         VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
 870                         DE_NULL,
 871
 872                         (m_config.compatibleFormat ? *m_renderPassCompatible : *m_renderPass),
 873                         *m_framebuffer,
 874
 875                         {
 876                                 { 0u, 0u },
 877                                 { m_config.width, m_config.height }
 878                         },
 879
 880                         2u,
 881                         clearValues
 882                 };
 883                 RenderpassSubpass2::cmdBeginRenderPass(vkd, *commandBuffer, &beginInfo, &subpassBeginInfo);
 884         }
 885
 886         // Render
 887         bool testingDepth = (m_config.verifyBuffer == VB_DEPTH);
 888         if (testingDepth)
 889         {
 890                 vkd.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_renderPipeline);
 891                 vkd.cmdDraw(*commandBuffer, 6u, 1u, 0u, 0u);
 892         }
 893         else
 894         {
 895                 // For stencil we can set reference value for just one sample at a time
 896                 // so we need to do as many passes as there are samples, first half
 897                 // of samples is initialized with 1 and second half with 255
 898                 const deUint32 halfOfSamples = m_config.sampleCount >> 1;
 899                 for (deUint32 renderPass = 0 ; renderPass < m_config.sampleCount ; renderPass++)
 900                 {
 901                         deUint32 stencilReference = 1 + 254 * (renderPass >= halfOfSamples);
 902                         vkd.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_renderPipeline);
 903                         vkd.cmdPushConstants(*commandBuffer, *m_renderPipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0u, sizeof(renderPass), &renderPass);
 904                         vkd.cmdSetStencilReference(*commandBuffer, VK_STENCIL_FRONT_AND_BACK, stencilReference);
 905                         vkd.cmdDraw(*commandBuffer, 6u, 1u, 0u, 0u);
 906                 }
 907         }
 908
 909         RenderpassSubpass2::cmdEndRenderPass(vkd, *commandBuffer, &subpassEndInfo);
 910
 911         // Memory barriers between rendering and copying
 912         {
 913                 const VkImageMemoryBarrier barrier =
 914                 {
 915                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 916                         DE_NULL,
 917
 918                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
 919                         VK_ACCESS_TRANSFER_READ_BIT,
 920
 921                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 922                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 923
 924                         VK_QUEUE_FAMILY_IGNORED,
 925                         VK_QUEUE_FAMILY_IGNORED,
 926
 927                         **m_singlesampleImage,
 928                         {
 929                                 (m_config.separateDepthStencilLayouts) ? VkImageAspectFlags(testingDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT) : m_config.aspectFlag,
 930                                 0u,
 931                                 1u,
 932                                 0u,
 933                                 m_config.viewLayers
 934                         }
 935                 };
 936
 937                 vkd.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &barrier);
 938         }
 939
 940         // Copy image memory to buffers
 941         const VkBufferImageCopy region =
 942         {
 943                 0u,
 944                 0u,
 945                 0u,
 946                 {
 947                         VkImageAspectFlags(testingDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT),
 948                         0u,
 949                         0u,
 950                         m_config.viewLayers,
 951                 },
 952                 { 0u, 0u, 0u },
 953                 { m_config.width, m_config.height, 1u }
 954         };
 955
 956         vkd.cmdCopyImageToBuffer(*commandBuffer, **m_singlesampleImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, **m_buffer, 1u, &region);
 957
 958         // Memory barriers between copies and host access
 959         {
 960                 const VkBufferMemoryBarrier barrier =
 961                 {
 962                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
 963                         DE_NULL,
 964
 965                         VK_ACCESS_TRANSFER_WRITE_BIT,
 966                         VK_ACCESS_HOST_READ_BIT,
 967
 968                         VK_QUEUE_FAMILY_IGNORED,
 969                         VK_QUEUE_FAMILY_IGNORED,
 970
 971                         **m_buffer,
 972                         0u,
 973                         VK_WHOLE_SIZE
 974                 };
 975
 976                 vkd.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &barrier, 0u, DE_NULL);
 977         }
 978
 979         endCommandBuffer(vkd, *commandBuffer);
 980
 981         submitCommandsAndWait(vkd, device, m_context.getUniversalQueue(), *commandBuffer);
 982 }
 983
 984 bool DepthStencilResolveTest::verifyDepth (void)
 985 {
 986         // Invalidate allocation before attempting to read buffer memory.
 987         invalidateAlloc(m_context.getDeviceInterface(), m_context.getDevice(), *m_bufferMemory);
 988
 989         deUint32                        layerSize       = m_config.width * m_config.height;
 990         deUint32                        valuesCount     = layerSize * m_config.viewLayers;
 991         deUint8*                        pixelPtr        = static_cast<deUint8*>(m_bufferMemory->getHostPtr());
 992
 993         const DeviceInterface&          vkd             (m_context.getDeviceInterface());
 994         invalidateMappedMemoryRange(vkd, m_context.getDevice(), m_bufferMemory->getMemory(), m_bufferMemory->getOffset(), VK_WHOLE_SIZE);
 995
 996         float expectedValue = m_config.depthExpectedValue;
 997         if (m_config.depthResolveMode == VK_RESOLVE_MODE_NONE || m_config.unusedResolve)
 998                 expectedValue = m_config.clearValue.depth;
 999
1000         // depth data in buffer is tightly packed, ConstPixelBufferAccess
1001         // coludn't be used for depth value extraction as it cant interpret
1002         // formats containing just depth component
1003
1004         typedef float (*DepthComponentGetterFn)(deUint8*);
1005         VkFormat                                format                          = m_config.format;
1006         DepthComponentGetterFn  getDepthComponent       = &get16bitDepthComponent;
1007         deUint32                                pixelStep                       = 2;
1008         float                                   epsilon                         = 0.002f;
1009
1010         if ((format == VK_FORMAT_X8_D24_UNORM_PACK32) ||
1011                 (format == VK_FORMAT_D24_UNORM_S8_UINT))
1012         {
1013                 getDepthComponent       = &get24bitDepthComponent;
1014                 pixelStep                       = 4;
1015         }
1016         else if ((format == VK_FORMAT_D32_SFLOAT) ||
1017                                 (format == VK_FORMAT_D32_SFLOAT_S8_UINT))
1018         {
1019                 getDepthComponent       = &get32bitDepthComponent;
1020                 pixelStep                       = 4;
1021         }
1022
1023         for (deUint32 valueIndex = 0; valueIndex < valuesCount; valueIndex++)
1024         {
1025                 float depth = (*getDepthComponent)(pixelPtr);
1026                 pixelPtr += pixelStep;
1027
1028                 // check if pixel data is outside of render area
1029                 deInt32 layerIndex              = valueIndex / layerSize;
1030                 deInt32 inLayerIndex    = valueIndex % layerSize;
1031                 deInt32 x                               = inLayerIndex % m_config.width;
1032                 deInt32 y                               = (inLayerIndex - x) / m_config.width;
1033                 deInt32 x1                              = m_config.renderArea.offset.x;
1034                 deInt32 y1                              = m_config.renderArea.offset.y;
1035                 deInt32 x2                              = x1 + m_config.renderArea.extent.width;
1036                 deInt32 y2                              = y1 + m_config.renderArea.extent.height;
1037                 if ((x < x1) || (x >= x2) || (y < y1) || (y >= y2))
1038                 {
1039                         // verify that outside of render area there are clear values
1040                         float error = deFloatAbs(depth - m_config.clearValue.depth);
1041                         if (error > epsilon)
1042                         {
1043                                 m_context.getTestContext().getLog()
1044                                 << TestLog::Message << "(" << x << ", " << y
1045                                 << ", layer: " << layerIndex << ") is outside of render area but depth value is: "
1046                                 << depth << " (expected " << m_config.clearValue.depth << ")" << TestLog::EndMessage;
1047                                 return false;
1048                         }
1049
1050                         // value is correct, go to next one
1051                         continue;
1052                 }
1053
1054                 float error = deFloatAbs(depth - expectedValue);
1055                 if (error > epsilon)
1056                 {
1057                         m_context.getTestContext().getLog() << TestLog::Message
1058                                 << "At (" << x << ", " << y << ", layer: " << layerIndex
1059                                 << ") depth value is: " << depth << " expected: "
1060                                 << expectedValue << TestLog::EndMessage;
1061                         return false;
1062                 }
1063         }
1064         m_context.getTestContext().getLog() << TestLog::Message
1065                 << "Depth value is " << expectedValue
1066                 << TestLog::EndMessage;
1067
1068         return true;
1069 }
1070
1071 bool DepthStencilResolveTest::verifyStencil (void)
1072 {
1073         // Invalidate allocation before attempting to read buffer memory.
1074         invalidateAlloc(m_context.getDeviceInterface(), m_context.getDevice(), *m_bufferMemory);
1075
1076         deUint32                        layerSize       = m_config.width * m_config.height;
1077         deUint32                        valuesCount     = layerSize * m_config.viewLayers;
1078         deUint8*                        pixelPtr        = static_cast<deUint8*>(m_bufferMemory->getHostPtr());
1079
1080         const DeviceInterface&          vkd             (m_context.getDeviceInterface());
1081         invalidateMappedMemoryRange(vkd, m_context.getDevice(), m_bufferMemory->getMemory(), m_bufferMemory->getOffset(), VK_WHOLE_SIZE);
1082
1083         // when stencil is tested we are discarding invocations and
1084         // because of that depth and stencil need to be tested separately
1085
1086         deUint8 expectedValue = m_config.stencilExpectedValue;
1087         if (m_config.stencilResolveMode == VK_RESOLVE_MODE_NONE || m_config.unusedResolve)
1088                 expectedValue = static_cast<deUint8>(m_config.clearValue.stencil);
1089
1090         for (deUint32 valueIndex = 0; valueIndex < valuesCount; valueIndex++)
1091         {
1092                 deUint8 stencil                 = *pixelPtr++;
1093                 deInt32 layerIndex              = valueIndex / layerSize;
1094                 deInt32 inLayerIndex    = valueIndex % layerSize;
1095                 deInt32 x                               = inLayerIndex % m_config.width;
1096                 deInt32 y                               = (inLayerIndex - x) / m_config.width;
1097                 deInt32 x1                              = m_config.renderArea.offset.x;
1098                 deInt32 y1                              = m_config.renderArea.offset.y;
1099                 deInt32 x2                              = x1 + m_config.renderArea.extent.width;
1100                 deInt32 y2                              = y1 + m_config.renderArea.extent.height;
1101                 if ((x < x1) || (x >= x2) || (y < y1) || (y >= y2))
1102                 {
1103                         if (stencil != m_config.clearValue.stencil)
1104                         {
1105                                 m_context.getTestContext().getLog()
1106                                 << TestLog::Message << "(" << x << ", " << y << ", layer: " << layerIndex
1107                                 << ") is outside of render area but stencil value is: "
1108                                 << stencil << " (expected " << m_config.clearValue.stencil << ")" << TestLog::EndMessage;
1109                                 return false;
1110                         }
1111
1112                         // value is correct, go to next one
1113                         continue;
1114                 }
1115
1116                 if (stencil != expectedValue)
1117                 {
1118                         m_context.getTestContext().getLog() << TestLog::Message
1119                                 << "At (" << x << ", " << y << ", layer: " << layerIndex
1120                                 << ") stencil value is: " << static_cast<deUint32>(stencil)
1121                                 << " expected: " << static_cast<deUint32>(expectedValue)
1122                                 << TestLog::EndMessage;
1123                         return false;
1124                 }
1125         }
1126         m_context.getTestContext().getLog() << TestLog::Message
1127                 << "Stencil value is "
1128                 << static_cast<deUint32>(expectedValue)
1129                 << TestLog::EndMessage;
1130
1131         return true;
1132 }
1133
1134 tcu::TestStatus DepthStencilResolveTest::iterate (void)
1135 {
1136         submit();
1137
1138         bool result = false;
1139         if (m_config.verifyBuffer == VB_DEPTH)
1140                 result = verifyDepth();
1141         else
1142                 result = verifyStencil();
1143
1144         if (result)
1145                 return tcu::TestStatus::pass("Pass");
1146         return tcu::TestStatus::fail("Fail");
1147 }
1148
1149 struct Programs
1150 {
1151         void init (vk::SourceCollections& dst, TestConfig config) const
1152         {
1153                 // geometry shader is only needed in multi-layer framebuffer resolve tests
1154                 if (config.imageLayers > 1)
1155                 {
1156                         const deUint32 layerCount = 3;
1157
1158                         std::ostringstream src;
1159                         src << "#version 450\n"
1160                                 << "highp float;\n"
1161                                 << "\n"
1162                                 << "layout(triangles) in;\n"
1163                                 << "layout(triangle_strip, max_vertices = " << 3 * 2 * layerCount << ") out;\n"
1164                                 << "\n"
1165                                 << "in gl_PerVertex {\n"
1166                                 << "    vec4 gl_Position;\n"
1167                                 << "} gl_in[];\n"
1168                                 << "\n"
1169                                 << "out gl_PerVertex {\n"
1170                                 << "    vec4 gl_Position;\n"
1171                                 << "};\n"
1172                                 << "\n"
1173                                 << "void main (void) {\n"
1174                                 << "    for (int layerNdx = 0; layerNdx < " << layerCount << "; ++layerNdx) {\n"
1175                                 << "        for(int vertexNdx = 0; vertexNdx < gl_in.length(); vertexNdx++) {\n"
1176                                 << "            gl_Position = gl_in[vertexNdx].gl_Position;\n"
1177                                 << "            gl_Layer    = layerNdx;\n"
1178                                 << "            EmitVertex();\n"
1179                                 << "        };\n"
1180                                 << "        EndPrimitive();\n"
1181                                 << "    };\n"
1182                                 << "}\n";
1183
1184                         dst.glslSources.add("quad-geom") << glu::GeometrySource(src.str());
1185                 }
1186
1187                 dst.glslSources.add("quad-vert") << glu::VertexSource(
1188                         "#version 450\n"
1189                         "out gl_PerVertex {\n"
1190                         "\tvec4 gl_Position;\n"
1191                         "};\n"
1192                         "highp float;\n"
1193                         "void main (void) {\n"
1194                         "\tgl_Position = vec4(((gl_VertexIndex + 2) / 3) % 2 == 0 ? -1.0 : 1.0,\n"
1195                         "\t                   ((gl_VertexIndex + 1) / 3) % 2 == 0 ? -1.0 : 1.0, 0.0, 1.0);\n"
1196                         "}\n");
1197
1198                 if (config.verifyBuffer == VB_DEPTH)
1199                 {
1200                         dst.glslSources.add("quad-frag") << glu::FragmentSource(
1201                                 "#version 450\n"
1202                                 "precision highp float;\n"
1203                                 "precision highp int;\n"
1204                                 "void main (void)\n"
1205                                 "{\n"
1206                                 "  float sampleIndex = float(gl_SampleID);\n"                           // sampleIndex is integer in range <0, 63>
1207                                 "  float valueIndex = round(mod(sampleIndex, 4.0));\n"          // limit possible depth values - count to 4
1208                                 "  float value = valueIndex + 2.0;\n"                                           // value is one of [2, 3, 4, 5]
1209                                 "  value = round(exp2(value));\n"                                                       // value is one of [4, 8, 16, 32]
1210                                 "  bool condition = (int(value) == 8);\n"                                       // select second sample value (to make it smallest)
1211                                 "  value = round(value - float(condition) * 6.0);\n"            // value is one of [4, 2, 16, 32]
1212                                 "  gl_FragDepth = value / 100.0;\n"                                                     // sample depth is one of [0.04, 0.02, 0.16, 0.32]
1213                                 "}\n");
1214                 }
1215                 else
1216                 {
1217                         dst.glslSources.add("quad-frag") << glu::FragmentSource(
1218                                 "#version 450\n"
1219                                 "precision highp float;\n"
1220                                 "precision highp int;\n"
1221                                 "layout(push_constant) uniform PushConstant {\n"
1222                                 "  highp int sampleID;\n"
1223                                 "} pushConstants;\n"
1224                                 "void main (void)\n"
1225                                 "{\n"
1226                                 "  if(gl_SampleID != pushConstants.sampleID)\n"
1227                                 "    discard;\n"
1228                                 "  gl_FragDepth = 0.5;\n"
1229                                 "}\n");
1230                 }
1231         }
1232 };
1233
1234 class PropertiesTestCase : public vkt::TestCase
1235 {
1236 public:
1237                                                         PropertiesTestCase              (tcu::TestContext& testCtx, const std::string& name, const std::string& description)
1238                                                                 : vkt::TestCase(testCtx, name, description)
1239                                                                 {}
1240         virtual                                 ~PropertiesTestCase             (void) {}
1241
1242         virtual TestInstance*   createInstance                  (Context& context) const;
1243         virtual void                    checkSupport                    (Context& context) const;
1244 };
1245
1246 class PropertiesTestInstance : public vkt::TestInstance
1247 {
1248 public:
1249                                                                 PropertiesTestInstance  (Context& context)
1250                                                                         : vkt::TestInstance(context)
1251                                                                         {}
1252         virtual                                         ~PropertiesTestInstance (void) {}
1253
1254         virtual tcu::TestStatus         iterate                                 (void);
1255
1256 };
1257
1258 TestInstance* PropertiesTestCase::createInstance (Context& context) const
1259 {
1260         return new PropertiesTestInstance(context);
1261 }
1262
1263 void PropertiesTestCase::checkSupport (Context& context) const
1264 {
1265         context.requireDeviceFunctionality("VK_KHR_depth_stencil_resolve");
1266 }
1267
1268 tcu::TestStatus PropertiesTestInstance::iterate (void)
1269 {
1270         vk::VkPhysicalDeviceDepthStencilResolvePropertiesKHR dsrProperties;
1271         dsrProperties.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR;
1272         dsrProperties.pNext = nullptr;
1273
1274         vk::VkPhysicalDeviceProperties2 properties2;
1275         properties2.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
1276         properties2.pNext = &dsrProperties;
1277
1278         m_context.getInstanceInterface().getPhysicalDeviceProperties2(m_context.getPhysicalDevice(), &properties2);
1279
1280         if ((dsrProperties.supportedDepthResolveModes & vk::VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR) == 0)
1281                 TCU_FAIL("supportedDepthResolveModes does not include VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR");
1282
1283         if ((dsrProperties.supportedStencilResolveModes & vk::VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR) == 0)
1284                 TCU_FAIL("supportedStencilResolveModes does not include VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR");
1285
1286         if ((dsrProperties.supportedStencilResolveModes & vk::VK_RESOLVE_MODE_AVERAGE_BIT_KHR) != 0)
1287                 TCU_FAIL("supportedStencilResolveModes includes forbidden VK_RESOLVE_MODE_AVERAGE_BIT_KHR");
1288
1289         if (dsrProperties.independentResolve == VK_TRUE && dsrProperties.independentResolveNone != VK_TRUE)
1290                 TCU_FAIL("independentResolve supported but independentResolveNone not supported");
1291
1292         return tcu::TestStatus::pass("Pass");
1293 }
1294
1295
1296 void initTests (tcu::TestCaseGroup* group)
1297 {
1298         typedef InstanceFactory1<DepthStencilResolveTest, TestConfig, Programs> DSResolveTestInstance;
1299
1300         struct FormatData
1301         {
1302                 VkFormat                format;
1303                 const char*             name;
1304                 bool                    hasDepth;
1305                 bool                    hasStencil;
1306         };
1307         FormatData formats[] =
1308         {
1309                 { VK_FORMAT_D16_UNORM,                          "d16_unorm",                    true,   false },
1310                 { VK_FORMAT_X8_D24_UNORM_PACK32,        "x8_d24_unorm_pack32",  true,   false },
1311                 { VK_FORMAT_D32_SFLOAT,                         "d32_sfloat",                   true,   false },
1312                 { VK_FORMAT_S8_UINT,                            "s8_uint",                              false,  true },
1313                 { VK_FORMAT_D16_UNORM_S8_UINT,          "d16_unorm_s8_uint",    true,   true },
1314                 { VK_FORMAT_D24_UNORM_S8_UINT,          "d24_unorm_s8_uint",    true,   true },
1315                 { VK_FORMAT_D32_SFLOAT_S8_UINT,         "d32_sfloat_s8_uint",   true,   true },
1316         };
1317
1318         struct ResolveModeData
1319         {
1320                 VkResolveModeFlagBits   flag;
1321                 std::string                             name;
1322         };
1323         ResolveModeData resolveModes[] =
1324         {
1325                 { VK_RESOLVE_MODE_NONE,                         "none" },
1326                 { VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,      "zero" },
1327                 { VK_RESOLVE_MODE_AVERAGE_BIT,          "average" },
1328                 { VK_RESOLVE_MODE_MIN_BIT,                      "min" },
1329                 { VK_RESOLVE_MODE_MAX_BIT,                      "max" },
1330         };
1331
1332         struct ImageTestData
1333         {
1334                 const char*                                     groupName;
1335                 deUint32                                        width;
1336                 deUint32                                        height;
1337                 deUint32                                        imageLayers;
1338                 VkRect2D                                        renderArea;
1339                 VkClearDepthStencilValue        clearValue;
1340         };
1341
1342         // NOTE: tests cant be executed for 1D and 3D images:
1343         // 1D images are not tested because acording to specyfication sampleCounts
1344         // will be set to VK_SAMPLE_COUNT_1_BIT when type is not VK_IMAGE_TYPE_2D
1345         // 3D images are not tested because VkFramebufferCreateInfo specification
1346         // states that: each element of pAttachments that is a 2D or 2D array image
1347         // view taken from a 3D image must not be a depth/stencil format
1348         ImageTestData imagesTestData[] =
1349         {
1350                 { "image_2d_32_32",     32, 32, 1, {{ 0,  0}, {32, 32}}, {0.000f, 0x00} },
1351                 { "image_2d_8_32",       8, 32, 1, {{ 1,  1}, { 6, 30}}, {0.123f, 0x01} },
1352                 { "image_2d_49_13",     49, 13, 1, {{10,  5}, {20,  8}}, {1.000f, 0x05} },
1353                 { "image_2d_5_1",        5,  1, 1, {{ 0,  0}, { 5,  1}}, {0.500f, 0x00} },
1354                 { "image_2d_17_1",      17,  1, 1, {{ 1,  0}, {15,  1}}, {0.789f, 0xfa} },
1355         };
1356         const deUint32 sampleCounts[] =
1357         {
1358                 2u, 4u, 8u, 16u, 32u, 64u
1359         };
1360         const float depthExpectedValue[][6] =
1361         {
1362                 // 2 samples    4                       8                       16                      32                      64
1363                 { 0.0f,                 0.0f,           0.0f,           0.0f,           0.0f,           0.0f },         // RESOLVE_MODE_NONE - expect clear value
1364                 { 0.04f,                0.04f,          0.04f,          0.04f,          0.04f,          0.04f },        // RESOLVE_MODE_SAMPLE_ZERO_BIT
1365                 { 0.03f,                0.135f,         0.135f,         0.135f,         0.135f,         0.135f },       // RESOLVE_MODE_AVERAGE_BIT
1366                 { 0.02f,                0.02f,          0.02f,          0.02f,          0.02f,          0.02f },        // RESOLVE_MODE_MIN_BIT
1367                 { 0.04f,                0.32f,          0.32f,          0.32f,          0.32f,          0.32f },        // RESOLVE_MODE_MAX_BIT
1368         };
1369         const deUint8 stencilExpectedValue[][6] =
1370         {
1371                 // 2 samples    4               8               16              32              64
1372                 { 0u,                   0u,             0u,             0u,             0u,             0u },   // RESOLVE_MODE_NONE - expect clear value
1373                 { 1u,                   1u,             1u,             1u,             1u,             1u },   // RESOLVE_MODE_SAMPLE_ZERO_BIT
1374                 { 0u,                   0u,             0u,             0u,             0u,             0u },   // RESOLVE_MODE_AVERAGE_BIT - not supported
1375                 { 1u,                   1u,             1u,             1u,             1u,             1u },   // RESOLVE_MODE_MIN_BIT
1376                 { 255u,                 255u,   255u,   255u,   255u,   255u }, // RESOLVE_MODE_MAX_BIT
1377         };
1378
1379         const DepthCompatibilityManager compatManager;
1380
1381         tcu::TestContext& testCtx(group->getTestContext());
1382
1383         // Misc tests.
1384         {
1385                 de::MovePtr<tcu::TestCaseGroup> miscGroup(new tcu::TestCaseGroup(testCtx, "misc", "Miscellaneous depth/stencil resolve tests"));
1386                 miscGroup->addChild(new PropertiesTestCase(testCtx, "properties", "Check reported depth/stencil resolve properties"));
1387                 group->addChild(miscGroup.release());
1388         }
1389
1390         // iterate over image data
1391         for      (deUint32 imageDataNdx = 0; imageDataNdx < DE_LENGTH_OF_ARRAY(imagesTestData); imageDataNdx++)
1392         {
1393                 ImageTestData imageData = imagesTestData[imageDataNdx];
1394
1395                 // create test group for image data
1396                 de::MovePtr<tcu::TestCaseGroup> imageGroup(new tcu::TestCaseGroup(testCtx, imageData.groupName, imageData.groupName));
1397
1398                 // iterate over sampleCounts
1399                 for (size_t sampleCountNdx = 0; sampleCountNdx < DE_LENGTH_OF_ARRAY(sampleCounts); sampleCountNdx++)
1400                 {
1401                         const deUint32          sampleCount     (sampleCounts[sampleCountNdx]);
1402                         const std::string       sampleName      ("samples_" + de::toString(sampleCount));
1403
1404                         // create test group for sample count
1405                         de::MovePtr<tcu::TestCaseGroup> sampleGroup(new tcu::TestCaseGroup(testCtx, sampleName.c_str(), sampleName.c_str()));
1406
1407                         // iterate over depth/stencil formats
1408                         for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1409                         {
1410                                 const FormatData&                       formatData                                      = formats[formatNdx];
1411                                 VkFormat                                        format                                          = formatData.format;
1412                                 const char*                                     formatName                                      = formatData.name;
1413                                 const bool                                      hasDepth                                        = formatData.hasDepth;
1414                                 const bool                                      hasStencil                                      = formatData.hasStencil;
1415                                 VkImageAspectFlags                      aspectFlags                                     = (hasDepth * VK_IMAGE_ASPECT_DEPTH_BIT) |
1416                                                                                                                                                   (hasStencil * VK_IMAGE_ASPECT_STENCIL_BIT);
1417                                 const int                                       separateLayoutsLoopCount        = (hasDepth && hasStencil) ? 2 : 1;
1418
1419                                 for (int separateDepthStencilLayouts = 0; separateDepthStencilLayouts < separateLayoutsLoopCount; ++separateDepthStencilLayouts)
1420                                 {
1421                                         const bool                      useSeparateDepthStencilLayouts  = bool(separateDepthStencilLayouts);
1422                                         const std::string       groupName                                               = std::string(formatName) + ((useSeparateDepthStencilLayouts) ? "_separate_layouts" : "");
1423
1424                                         // create test group for format
1425                                         de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupName.c_str()));
1426
1427                                         // iterate over depth resolve modes
1428                                         for (size_t depthResolveModeNdx = 0; depthResolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); depthResolveModeNdx++)
1429                                         {
1430                                                 // iterate over stencil resolve modes
1431                                                 for (size_t stencilResolveModeNdx = 0; stencilResolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); stencilResolveModeNdx++)
1432                                                 {
1433                                                         for (int unusedIdx = 0; unusedIdx < 2; ++unusedIdx)
1434                                                         {
1435                                                                 // there is no average resolve mode for stencil - go to next iteration
1436                                                                 ResolveModeData& sResolve = resolveModes[stencilResolveModeNdx];
1437                                                                 if (sResolve.flag == VK_RESOLVE_MODE_AVERAGE_BIT)
1438                                                                         continue;
1439
1440                                                                 // if pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED,
1441                                                                 // depthResolveMode and stencilResolveMode must not both be VK_RESOLVE_MODE_NONE_KHR
1442                                                                 ResolveModeData& dResolve = resolveModes[depthResolveModeNdx];
1443                                                                 if ((dResolve.flag == VK_RESOLVE_MODE_NONE) && (sResolve.flag == VK_RESOLVE_MODE_NONE))
1444                                                                         continue;
1445
1446                                                                 // If there is no depth, the depth resolve mode should be NONE, or
1447                                                                 // match the stencil resolve mode.
1448                                                                 if (!hasDepth && (dResolve.flag != VK_RESOLVE_MODE_NONE) &&
1449                                                                         (dResolve.flag != sResolve.flag))
1450                                                                         continue;
1451
1452                                                                 // If there is no stencil, the stencil resolve mode should be NONE, or
1453                                                                 // match the depth resolve mode.
1454                                                                 if (!hasStencil && (sResolve.flag != VK_RESOLVE_MODE_NONE) &&
1455                                                                         (dResolve.flag != sResolve.flag))
1456                                                                         continue;
1457
1458                                                                 const bool unusedResolve = (unusedIdx > 0);
1459
1460                                                                 std::string baseName = "depth_" + dResolve.name + "_stencil_" + sResolve.name;
1461                                                                 if (unusedResolve)
1462                                                                         baseName += "_unused_resolve";
1463
1464                                                                 if (hasDepth)
1465                                                                 {
1466                                                                         std::string     name                    = baseName + "_testing_depth";
1467                                                                         const char*     testName                = name.c_str();
1468                                                                         float           expectedValue   = depthExpectedValue[depthResolveModeNdx][sampleCountNdx];
1469
1470                                                                         const TestConfig testConfig =
1471                                                                         {
1472                                                                                 format,
1473                                                                                 imageData.width,
1474                                                                                 imageData.height,
1475                                                                                 1u,
1476                                                                                 1u,
1477                                                                                 0u,
1478                                                                                 imageData.renderArea,
1479                                                                                 aspectFlags,
1480                                                                                 sampleCount,
1481                                                                                 dResolve.flag,
1482                                                                                 sResolve.flag,
1483                                                                                 VB_DEPTH,
1484                                                                                 imageData.clearValue,
1485                                                                                 expectedValue,
1486                                                                                 0u,
1487                                                                                 useSeparateDepthStencilLayouts,
1488                                                                                 unusedResolve,
1489                                                                                 tcu::nothing<VkFormat>(),
1490                                                                         };
1491                                                                         formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
1492
1493                                                                         if (sampleCountNdx == 0 && imageDataNdx == 0)
1494                                                                         {
1495                                                                                 const auto compatibleFormat = compatManager.getAlternativeFormat(format);
1496
1497                                                                                 if (compatibleFormat != VK_FORMAT_UNDEFINED)
1498                                                                                 {
1499                                                                                         std::string     compatibilityTestName                   = "compatibility_" + name;
1500                                                                                         TestConfig compatibilityTestConfig                      = testConfig;
1501                                                                                         compatibilityTestConfig.compatibleFormat        = tcu::just(compatibleFormat);
1502
1503                                                                                         formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, compatibilityTestName.c_str(), compatibilityTestName.c_str(), compatibilityTestConfig));
1504                                                                                 }
1505                                                                         }
1506                                                                 }
1507                                                                 if (hasStencil)
1508                                                                 {
1509                                                                         std::string     name                    = baseName + "_testing_stencil";
1510                                                                         const char*     testName                = name.c_str();
1511                                                                         deUint8         expectedValue   = stencilExpectedValue[stencilResolveModeNdx][sampleCountNdx];
1512
1513                                                                         const TestConfig testConfig =
1514                                                                         {
1515                                                                                 format,
1516                                                                                 imageData.width,
1517                                                                                 imageData.height,
1518                                                                                 1u,
1519                                                                                 1u,
1520                                                                                 0u,
1521                                                                                 imageData.renderArea,
1522                                                                                 aspectFlags,
1523                                                                                 sampleCount,
1524                                                                                 dResolve.flag,
1525                                                                                 sResolve.flag,
1526                                                                                 VB_STENCIL,
1527                                                                                 imageData.clearValue,
1528                                                                                 0.0f,
1529                                                                                 expectedValue,
1530                                                                                 useSeparateDepthStencilLayouts,
1531                                                                                 unusedResolve,
1532                                                                                 tcu::nothing<VkFormat>(),
1533                                                                         };
1534                                                                         formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
1535
1536                                                                         // All formats with stencil and depth aspects have incompatible formats and sizes in the depth
1537                                                                         // aspect, so their only alternative is the VK_FORMAT_S8_UINT format. Finally, that stencil-only
1538                                                                         // format has no compatible formats that can be used.
1539                                                                         if (sampleCountNdx == 0 && imageDataNdx == 0 && hasDepth)
1540                                                                         {
1541                                                                                 std::string     compatibilityTestName                   = "compatibility_" + name;
1542                                                                                 TestConfig compatibilityTestConfig                      = testConfig;
1543                                                                                 compatibilityTestConfig.compatibleFormat        = tcu::just(VK_FORMAT_S8_UINT);
1544
1545                                                                                 formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, compatibilityTestName.c_str(), compatibilityTestName.c_str(), compatibilityTestConfig));
1546                                                                         }
1547                                                                 }
1548                                                         }
1549                                                 }
1550                                         }
1551                                         sampleGroup->addChild(formatGroup.release());
1552                                 }
1553                         }
1554
1555                         imageGroup->addChild(sampleGroup.release());
1556                 }
1557
1558                 group->addChild(imageGroup.release());
1559         }
1560
1561         {
1562                 // layered texture tests are done for all stencil modes and depth modes - not all combinations
1563                 // Test checks if all layer are resolved in multi-layered framebuffer and if we can have a framebuffer
1564                 // which starts at a layer other than zero. Both parts are tested together by rendering to layers
1565                 // 4-6 and resolving to layers 1-3.
1566                 ImageTestData layeredTextureTestData =
1567                 {
1568                         "image_2d_16_64_6", 16, 64, 6, {{ 10,  10}, {6, 54}}, {1.0f, 0x0}
1569                 };
1570
1571                 de::MovePtr<tcu::TestCaseGroup> imageGroup(new tcu::TestCaseGroup(testCtx, layeredTextureTestData.groupName, layeredTextureTestData.groupName));
1572
1573                 for (size_t sampleCountNdx = 0; sampleCountNdx < DE_LENGTH_OF_ARRAY(sampleCounts); sampleCountNdx++)
1574                 {
1575                         const deUint32          sampleCount     (sampleCounts[sampleCountNdx]);
1576                         const std::string       sampleName      ("samples_" + de::toString(sampleCount));
1577
1578                         // create test group for sample count
1579                         de::MovePtr<tcu::TestCaseGroup> sampleGroup(new tcu::TestCaseGroup(testCtx, sampleName.c_str(), sampleName.c_str()));
1580
1581                         // iterate over depth/stencil formats
1582                         for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
1583                         {
1584                                 const FormatData&                       formatData                                      = formats[formatNdx];
1585                                 VkFormat                                        format                                          = formatData.format;
1586                                 const char*                                     formatName                                      = formatData.name;
1587                                 const bool                                      hasDepth                                        = formatData.hasDepth;
1588                                 const bool                                      hasStencil                                      = formatData.hasStencil;
1589                                 VkImageAspectFlags                      aspectFlags                                     = (hasDepth * VK_IMAGE_ASPECT_DEPTH_BIT) |
1590                                                                                                                                                   (hasStencil * VK_IMAGE_ASPECT_STENCIL_BIT);
1591                                 const int                                       separateLayoutsLoopCount        = (hasDepth && hasStencil) ? 2 : 1;
1592
1593                                 for (int separateDepthStencilLayouts = 0; separateDepthStencilLayouts < separateLayoutsLoopCount; ++separateDepthStencilLayouts)
1594                                 {
1595                                         const bool                      useSeparateDepthStencilLayouts  = bool(separateDepthStencilLayouts);
1596                                         const std::string       groupName                                               = std::string(formatName) + ((useSeparateDepthStencilLayouts) ? "_separate_layouts" : "");
1597
1598                                         // create test group for format
1599                                         de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupName.c_str()));
1600
1601                                         for (size_t resolveModeNdx = 0; resolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); resolveModeNdx++)
1602                                         {
1603                                                 for (int unusedIdx = 0; unusedIdx < 2; ++unusedIdx)
1604                                                 {
1605                                                         ResolveModeData& mode = resolveModes[resolveModeNdx];
1606
1607                                                         const bool                      unusedResolve   = (unusedIdx > 0);
1608                                                         const std::string       unusedSuffix    = (unusedResolve ? "_unused_resolve" : "");
1609
1610                                                         if (hasDepth)
1611                                                         {
1612                                                                 std::string     name                    = "depth_" + mode.name + unusedSuffix;
1613                                                                 const char*     testName                = name.c_str();
1614                                                                 float           expectedValue   = depthExpectedValue[resolveModeNdx][sampleCountNdx];
1615                                                                 const TestConfig testConfig =
1616                                                                 {
1617                                                                         format,
1618                                                                         layeredTextureTestData.width,
1619                                                                         layeredTextureTestData.height,
1620                                                                         layeredTextureTestData.imageLayers,
1621                                                                         3u,
1622                                                                         0u,
1623                                                                         layeredTextureTestData.renderArea,
1624                                                                         aspectFlags,
1625                                                                         sampleCount,
1626                                                                         mode.flag,
1627                                                                         VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
1628                                                                         VB_DEPTH,
1629                                                                         layeredTextureTestData.clearValue,
1630                                                                         expectedValue,
1631                                                                         0u,
1632                                                                         useSeparateDepthStencilLayouts,
1633                                                                         unusedResolve,
1634                                                                         tcu::nothing<VkFormat>(),
1635                                                                 };
1636                                                                 formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
1637                                                         }
1638
1639                                                         // there is no average resolve mode for stencil - go to next iteration
1640                                                         if (mode.flag == VK_RESOLVE_MODE_AVERAGE_BIT)
1641                                                                 continue;
1642
1643                                                         if (hasStencil)
1644                                                         {
1645                                                                 std::string     name                    = "stencil_" + mode.name + unusedSuffix;
1646                                                                 const char*     testName                = name.c_str();
1647                                                                 deUint8         expectedValue   = stencilExpectedValue[resolveModeNdx][sampleCountNdx];
1648                                                                 const TestConfig testConfig =
1649                                                                 {
1650                                                                         format,
1651                                                                         layeredTextureTestData.width,
1652                                                                         layeredTextureTestData.height,
1653                                                                         layeredTextureTestData.imageLayers,
1654                                                                         3u,
1655                                                                         0u,
1656                                                                         layeredTextureTestData.renderArea,
1657                                                                         aspectFlags,
1658                                                                         sampleCount,
1659                                                                         VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
1660                                                                         mode.flag,
1661                                                                         VB_STENCIL,
1662                                                                         layeredTextureTestData.clearValue,
1663                                                                         0.0f,
1664                                                                         expectedValue,
1665                                                                         useSeparateDepthStencilLayouts,
1666                                                                         unusedResolve,
1667                                                                         tcu::nothing<VkFormat>(),
1668                                                                 };
1669                                                                 formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
1670                                                         }
1671                                                 }
1672                                         }
1673                                         sampleGroup->addChild(formatGroup.release());
1674                                 }
1675                         }
1676                         imageGroup->addChild(sampleGroup.release());
1677                 }
1678
1679                 group->addChild(imageGroup.release());
1680         }
1681 }
1682
1683 } // anonymous
1684
1685 tcu::TestCaseGroup* createRenderPass2DepthStencilResolveTests (tcu::TestContext& testCtx)
1686 {
1687         return createTestGroup(testCtx, "depth_stencil_resolve", "Depth/stencil resolve tests", initTests);
1688 }
1689
1690 } // vkt