external/vulkancts/modules/vulkan/api/vktApiImageClearingTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   6  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Vulkan Image Clearing Tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktApiImageClearingTests.hpp"
  26
  27 #include "deRandom.hpp"
  28 #include "deMath.h"
  29 #include "deSTLUtil.hpp"
  30 #include "deStringUtil.hpp"
  31 #include "deUniquePtr.hpp"
  32 #include "deArrayUtil.hpp"
  33 #include "deInt32.h"
  34 #include "vkImageUtil.hpp"
  35 #include "vkMemUtil.hpp"
  36 #include "vktTestCase.hpp"
  37 #include "vktTestCaseUtil.hpp"
  38 #include "vktTestGroupUtil.hpp"
  39 #include "vkQueryUtil.hpp"
  40 #include "vkRefUtil.hpp"
  41 #include "vkTypeUtil.hpp"
  42 #include "vkCmdUtil.hpp"
  43 #include "tcuImageCompare.hpp"
  44 #include "tcuTexture.hpp"
  45 #include "tcuTextureUtil.hpp"
  46 #include "tcuVectorType.hpp"
  47 #include "tcuTexture.hpp"
  48 #include "tcuFloat.hpp"
  49 #include "tcuTestLog.hpp"
  50 #include "tcuVectorUtil.hpp"
  51 #include <sstream>
  52 #include <numeric>
  53
  54 namespace vkt
  55 {
  56
  57 namespace api
  58 {
  59
  60 using namespace vk;
  61 using namespace tcu;
  62
  63 namespace
  64 {
  65
  66 enum AllocationKind
  67 {
  68         ALLOCATION_KIND_SUBALLOCATED = 0,
  69         ALLOCATION_KIND_DEDICATED,
  70
  71         ALLOCATION_KIND_LAST,
  72 };
  73
  74 de::MovePtr<Allocation> allocateBuffer (const InstanceInterface&        vki,
  75                                                                                 const DeviceInterface&          vkd,
  76                                                                                 const VkPhysicalDevice&         physDevice,
  77                                                                                 const VkDevice                          device,
  78                                                                                 const VkBuffer&                         buffer,
  79                                                                                 const MemoryRequirement         requirement,
  80                                                                                 Allocator&                                      allocator,
  81                                                                                 AllocationKind                          allocationKind)
  82 {
  83         switch (allocationKind)
  84         {
  85                 case ALLOCATION_KIND_SUBALLOCATED:
  86                 {
  87                         const VkMemoryRequirements memoryRequirements = getBufferMemoryRequirements(vkd, device, buffer);
  88
  89                         return allocator.allocate(memoryRequirements, requirement);
  90                 }
  91
  92                 case ALLOCATION_KIND_DEDICATED:
  93                 {
  94                         return allocateDedicated(vki, vkd, physDevice, device, buffer, requirement);
  95                 }
  96
  97                 default:
  98                 {
  99                         TCU_THROW(InternalError, "Invalid allocation kind");
 100                 }
 101         }
 102 }
 103
 104 de::MovePtr<Allocation> allocateImage (const InstanceInterface&         vki,
 105                                                                            const DeviceInterface&               vkd,
 106                                                                            const VkPhysicalDevice&              physDevice,
 107                                                                            const VkDevice                               device,
 108                                                                            const VkImage&                               image,
 109                                                                            const MemoryRequirement              requirement,
 110                                                                            Allocator&                                   allocator,
 111                                                                            AllocationKind                               allocationKind)
 112 {
 113         switch (allocationKind)
 114         {
 115                 case ALLOCATION_KIND_SUBALLOCATED:
 116                 {
 117                         const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vkd, device, image);
 118
 119                         return allocator.allocate(memoryRequirements, requirement);
 120                 }
 121
 122                 case ALLOCATION_KIND_DEDICATED:
 123                 {
 124                         return allocateDedicated(vki, vkd, physDevice, device, image, requirement);
 125                 }
 126
 127                 default:
 128                 {
 129                         TCU_THROW(InternalError, "Invalid allocation kind");
 130                 }
 131         }
 132 }
 133
 134 VkExtent3D getMipLevelExtent (VkExtent3D baseExtent, const deUint32 mipLevel)
 135 {
 136         baseExtent.width        = std::max(baseExtent.width  >> mipLevel, 1u);
 137         baseExtent.height       = std::max(baseExtent.height >> mipLevel, 1u);
 138         baseExtent.depth        = std::max(baseExtent.depth  >> mipLevel, 1u);
 139         return baseExtent;
 140 }
 141
 142 deUint32 getNumMipLevels (const VkExtent3D& baseExtent, const deUint32 maxMipLevels)
 143 {
 144         const deUint32 widestEdge = std::max(std::max(baseExtent.width, baseExtent.height), baseExtent.depth);
 145         return std::min(static_cast<deUint32>(deFloatLog2(static_cast<float>(widestEdge))) + 1u, maxMipLevels);
 146 }
 147
 148 deUint32 greatestCommonDivisor (const deUint32 a, const deUint32 b)
 149 {
 150         /* Find GCD */
 151         deUint32 temp;
 152         deUint32 x=a;
 153         deUint32 y=b;
 154
 155         while (x%y != 0)
 156         {
 157                 temp = y;
 158                 y = x%y;
 159                 x = temp;
 160         }
 161         return y;
 162 }
 163
 164 deUint32 lowestCommonMultiple (const deUint32 a, const deUint32 b)
 165 {
 166         return (a*b)/greatestCommonDivisor(a,b);
 167 }
 168
 169 std::vector<deUint32> getImageMipLevelSizes (const deUint32 pixelSize, const VkExtent3D& baseExtent, const deUint32 numMipLevels, const deUint32 perLevelAlignment = 1u)
 170 {
 171         std::vector<deUint32> results(numMipLevels);
 172
 173         for (deUint32 mipLevel = 0; mipLevel < numMipLevels; ++mipLevel)
 174         {
 175                 const VkExtent3D extent = getMipLevelExtent(baseExtent, mipLevel);
 176                 results[mipLevel] = static_cast<deUint32>(extent.width * extent.height * extent.depth * pixelSize);
 177                 results[mipLevel] = ((results[mipLevel] + perLevelAlignment-1) / perLevelAlignment) * perLevelAlignment;
 178         }
 179
 180         return results;
 181 }
 182
 183 struct LayerRange
 184 {
 185         deUint32 baseArrayLayer;
 186         deUint32 layerCount;
 187 };
 188
 189 inline bool isInClearRange (const UVec4& clearCoords, const deUint32 x, const deUint32 y, deUint32 arrayLayer = 0, tcu::Maybe<LayerRange> imageViewLayerRange = tcu::Maybe<LayerRange>(), tcu::Maybe<LayerRange> attachmentClearLayerRange = tcu::Maybe<LayerRange>())
 190 {
 191         if (attachmentClearLayerRange)
 192         {
 193                 // Only layers in range passed to clear command are cleared
 194
 195                 const deUint32  clearBaseLayer  = (imageViewLayerRange ? imageViewLayerRange->baseArrayLayer : 0) + attachmentClearLayerRange->baseArrayLayer;
 196                 const deUint32  clearLayerCount = (attachmentClearLayerRange->layerCount == VK_REMAINING_ARRAY_LAYERS) ? imageViewLayerRange->layerCount : clearBaseLayer + attachmentClearLayerRange->layerCount;
 197
 198                 if ((arrayLayer < clearBaseLayer) || (arrayLayer >= (clearLayerCount)))
 199                 {
 200                         return false;
 201                 }
 202         }
 203
 204         if (clearCoords == UVec4())
 205         {
 206                 return true;
 207         }
 208
 209         //! Check if a point lies in a cross-like area.
 210         return !((x <  clearCoords[0] && y <  clearCoords[1]) ||
 211                          (x <  clearCoords[0] && y >= clearCoords[3]) ||
 212                          (x >= clearCoords[2] && y <  clearCoords[1]) ||
 213                          (x >= clearCoords[2] && y >= clearCoords[3]));
 214 }
 215
 216 inline bool isInInitialClearRange (bool isAttachmentformat, deUint32 mipLevel, deUint32 arrayLayer, LayerRange imageViewLayerRange)
 217 {
 218         if (!isAttachmentformat)
 219         {
 220                 // initial clear is done using renderpass load op - does not apply for non-renderable formats
 221                 return false;
 222         }
 223
 224         if (mipLevel > 0)
 225         {
 226                 // intial clear is done using FB bound to level 0 only
 227                 return false;
 228         }
 229
 230         // Only layers in range bound to framebuffer are cleared to initial color
 231         if ((arrayLayer < imageViewLayerRange.baseArrayLayer) || (arrayLayer >= (imageViewLayerRange.baseArrayLayer + imageViewLayerRange.layerCount)))
 232         {
 233                 return false;
 234         }
 235
 236         return true;
 237 }
 238
 239 // This method is copied from the vktRenderPassTests.cpp. It should be moved to a common place.
 240 int calcFloatDiff (float a, float b)
 241 {
 242         const int                       asign   = Float32(a).sign();
 243         const int                       bsign   = Float32(a).sign();
 244
 245         const deUint32          avalue  = (Float32(a).bits() & ((0x1u << 31u) - 1u));
 246         const deUint32          bvalue  = (Float32(b).bits() & ((0x1u << 31u) - 1u));
 247
 248         if (asign != bsign)
 249                 return avalue + bvalue + 1u;
 250         else if (avalue < bvalue)
 251                 return bvalue - avalue;
 252         else
 253                 return avalue - bvalue;
 254 }
 255
 256 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
 257 bool comparePixelToDepthClearValue (const ConstPixelBufferAccess&       access,
 258                                                                         int                                                             x,
 259                                                                         int                                                             y,
 260                                                                         float                                                   ref,
 261                                                                         std::string&                                    stringResult)
 262 {
 263         const TextureFormat                     format                  = getEffectiveDepthStencilTextureFormat(access.getFormat(), Sampler::MODE_DEPTH);
 264         const TextureChannelClass       channelClass    = getTextureChannelClass(format.type);
 265
 266         switch (channelClass)
 267         {
 268                 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 269                 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 270                 {
 271                         const int       bitDepth        = getTextureFormatBitDepth(format).x();
 272                         const float     depth           = access.getPixDepth(x, y);
 273                         const float     threshold       = 2.0f / (float)((1 << bitDepth) - 1);
 274                         const bool      result          = deFloatAbs(depth - ref) <= threshold;
 275
 276                         if (!result)
 277                         {
 278                                 std::stringstream s;
 279                                 s << "Ref:" << ref << " Threshold:" << threshold << " Depth:" << depth;
 280                                 stringResult    = s.str();
 281                         }
 282
 283                         return result;
 284                 }
 285
 286                 case TEXTURECHANNELCLASS_FLOATING_POINT:
 287                 {
 288                         const float     depth                   = access.getPixDepth(x, y);
 289                         const int       mantissaBits    = getTextureFormatMantissaBitDepth(format).x();
 290                         const int       threshold               = 10 * 1 << (23 - mantissaBits);
 291
 292                         DE_ASSERT(mantissaBits <= 23);
 293
 294                         const bool      result                  = calcFloatDiff(depth, ref) <= threshold;
 295
 296                         if (!result)
 297                         {
 298                                 float                           floatThreshold  = Float32((deUint32)threshold).asFloat();
 299                                 std::stringstream       s;
 300
 301                                 s << "Ref:" << ref << " Threshold:" << floatThreshold << " Depth:" << depth;
 302                                 stringResult    = s.str();
 303                         }
 304
 305                         return result;
 306                 }
 307
 308                 default:
 309                         DE_FATAL("Invalid channel class");
 310                         return false;
 311         }
 312 }
 313
 314 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
 315 bool comparePixelToStencilClearValue (const ConstPixelBufferAccess&     access,
 316                                                                           int                                                   x,
 317                                                                           int                                                   y,
 318                                                                           deUint32                                              ref,
 319                                                                           std::string&                                  stringResult)
 320 {
 321         const deUint32  stencil = access.getPixStencil(x, y);
 322         const bool              result  = stencil == ref;
 323
 324         if (!result)
 325         {
 326                 std::stringstream s;
 327                 s << "Ref:" << ref << " Threshold:0" << " Stencil:" << stencil;
 328                 stringResult    = s.str();
 329         }
 330
 331         return result;
 332 }
 333
 334 // This method is copied from the vktRenderPassTests.cpp and extended with the stringResult parameter.
 335 bool comparePixelToColorClearValue (const ConstPixelBufferAccess&       access,
 336                                                                         int                                                             x,
 337                                                                         int                                                             y,
 338                                                                         int                                                             z,
 339                                                                         const VkClearColorValue&                ref,
 340                                                                         std::string&                                    stringResult)
 341 {
 342         const TextureFormat                             format                  = access.getFormat();
 343         const TextureChannelClass               channelClass    = getTextureChannelClass(format.type);
 344         const BVec4                                             channelMask             = getTextureFormatChannelMask(format);
 345
 346         switch (channelClass)
 347         {
 348                 case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 349                 case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 350                 {
 351                         const IVec4     bitDepth        (getTextureFormatBitDepth(format));
 352                         const Vec4      resColor        (access.getPixel(x, y, z));
 353                         Vec4            refColor        (ref.float32[0],
 354                                                                          ref.float32[1],
 355                                                                          ref.float32[2],
 356                                                                          ref.float32[3]);
 357                         const int       modifier        = (channelClass == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT) ? 0 : 1;
 358                         const Vec4      threshold       (bitDepth[0] > 0 ? 1.0f / ((float)(1 << (bitDepth[0] - modifier)) - 1.0f) : 1.0f,
 359                                                                          bitDepth[1] > 0 ? 1.0f / ((float)(1 << (bitDepth[1] - modifier)) - 1.0f) : 1.0f,
 360                                                                          bitDepth[2] > 0 ? 1.0f / ((float)(1 << (bitDepth[2] - modifier)) - 1.0f) : 1.0f,
 361                                                                          bitDepth[3] > 0 ? 1.0f / ((float)(1 << (bitDepth[3] - modifier)) - 1.0f) : 1.0f);
 362
 363                         if (isSRGB(access.getFormat()))
 364                                 refColor        = linearToSRGB(refColor);
 365
 366                         const bool      result          = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
 367
 368                         if (!result)
 369                         {
 370                                 std::stringstream s;
 371                                 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
 372                                 stringResult    = s.str();
 373                         }
 374
 375                         return result;
 376                 }
 377
 378                 case TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 379                 {
 380                         const UVec4     resColor        (access.getPixelUint(x, y, z));
 381                         const UVec4     refColor        (ref.uint32[0],
 382                                                                          ref.uint32[1],
 383                                                                          ref.uint32[2],
 384                                                                          ref.uint32[3]);
 385                         const UVec4     threshold       (1);
 386
 387                         const bool      result          = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
 388
 389                         if (!result)
 390                         {
 391                                 std::stringstream s;
 392                                 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
 393                                 stringResult    = s.str();
 394                         }
 395
 396                         return result;
 397                 }
 398
 399                 case TEXTURECHANNELCLASS_SIGNED_INTEGER:
 400                 {
 401                         const IVec4     resColor        (access.getPixelInt(x, y, z));
 402                         const IVec4     refColor        (ref.int32[0],
 403                                                                          ref.int32[1],
 404                                                                          ref.int32[2],
 405                                                                          ref.int32[3]);
 406                         const IVec4     threshold       (1);
 407
 408                         const bool      result          = !(anyNotEqual(logicalAnd(lessThanEqual(absDiff(resColor, refColor), threshold), channelMask), channelMask));
 409
 410                         if (!result)
 411                         {
 412                                 std::stringstream s;
 413                                 s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << threshold << " Color:" << resColor;
 414                                 stringResult    = s.str();
 415                         }
 416
 417                         return result;
 418                 }
 419
 420                 case TEXTURECHANNELCLASS_FLOATING_POINT:
 421                 {
 422                         const Vec4      resColor                (access.getPixel(x, y, z));
 423                         const Vec4      refColor                (ref.float32[0],
 424                                                                                  ref.float32[1],
 425                                                                                  ref.float32[2],
 426                                                                                  ref.float32[3]);
 427                         const IVec4     mantissaBits    (getTextureFormatMantissaBitDepth(format));
 428                         const IVec4     threshold               (10 * IVec4(1) << (23 - mantissaBits));
 429
 430                         DE_ASSERT(allEqual(greaterThanEqual(threshold, IVec4(0)), BVec4(true)));
 431
 432                         for (int ndx = 0; ndx < 4; ndx++)
 433                         {
 434                                 const bool result       = !(calcFloatDiff(resColor[ndx], refColor[ndx]) > threshold[ndx] && channelMask[ndx]);
 435
 436                                 if (!result)
 437                                 {
 438                                         float                           floatThreshold  = Float32((deUint32)(threshold)[0]).asFloat();
 439                                         Vec4                            thresholdVec4   (floatThreshold,
 440                                                                                                                  floatThreshold,
 441                                                                                                                  floatThreshold,
 442                                                                                                                  floatThreshold);
 443                                         std::stringstream       s;
 444                                         s << "Ref:" << refColor << " Mask:" << channelMask << " Threshold:" << thresholdVec4 << " Color:" << resColor;
 445                                         stringResult    = s.str();
 446
 447                                         return false;
 448                                 }
 449                         }
 450
 451                         return true;
 452                 }
 453
 454                 default:
 455                         DE_FATAL("Invalid channel class");
 456                         return false;
 457         }
 458 }
 459
 460 std::string extentToString (VkExtent3D extent, VkImageType imageType)
 461 {
 462         // Don't append image dimensions when using the dimensions found in original test cases. This avoids name clashing with the old versions.
 463         if (imageType == VK_IMAGE_TYPE_1D && extent.width == 256u) return "";
 464         if (imageType == VK_IMAGE_TYPE_2D && extent.width == 256u && extent.height == 256u) return "";
 465         if (imageType == VK_IMAGE_TYPE_3D && extent.width == 256u && extent.height == 256u && extent.depth == 16u) return "";
 466
 467         return (std::string("_") + de::toString(extent.width) + std::string("x") + de::toString(extent.height) + (extent.depth != 1 ? (std::string("x") + de::toString(extent.depth)) : ""));
 468 }
 469
 470 enum SeparateDepthStencilLayoutMode
 471 {
 472         SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE = 0,
 473         SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH,
 474         SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL,
 475 };
 476
 477 struct TestParams
 478 {
 479         bool                                                    useSingleMipLevel;      //!< only mip level 0, otherwise up to maxMipLevels
 480         VkImageType                                             imageType;
 481         VkFormat                                                imageFormat;
 482         VkImageTiling                                   imageTiling;
 483         VkExtent3D                                              imageExtent;
 484         deUint32                                                imageLayerCount;
 485         LayerRange                                              imageViewLayerRange;
 486         VkClearValue                                    initValue;
 487         VkClearValue                                    clearValue[2];          //!< the second value is used with more than one mip map
 488         LayerRange                                              clearLayerRange;
 489         AllocationKind                                  allocationKind;
 490         bool                                                    isCube;
 491         SeparateDepthStencilLayoutMode  separateDepthStencilLayoutMode;
 492 };
 493
 494 class ImageClearingTestInstance : public vkt::TestInstance
 495 {
 496 public:
 497                                                                                 ImageClearingTestInstance               (Context&                       context,
 498                                                                                                                                                  const TestParams&      testParams);
 499
 500         Move<VkCommandPool>                                     createCommandPool                               (VkCommandPoolCreateFlags commandPoolCreateFlags) const;
 501         Move<VkCommandBuffer>                           allocatePrimaryCommandBuffer    (VkCommandPool commandPool) const;
 502         Move<VkImage>                                           createImage                                             (VkImageType imageType, VkFormat format, VkImageTiling tiling, VkExtent3D extent, deUint32 arrayLayerCount, VkImageUsageFlags usage) const;
 503         Move<VkImageView>                                       createImageView                                 (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask, LayerRange layerRange) const;
 504         Move<VkRenderPass>                                      createRenderPass                                (VkFormat format) const;
 505         Move<VkFramebuffer>                                     createFrameBuffer                               (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight, deUint32 imageLayersCount) const;
 506
 507         void                                                            beginCommandBuffer                              (VkCommandBufferUsageFlags usageFlags) const;
 508         void                                                            endCommandBuffer                                (void) const;
 509         void                                                            submitCommandBuffer                             (void) const;
 510         void                                                            beginRenderPass                                 (VkSubpassContents content, VkClearValue clearValue) const;
 511
 512         void                                                            pipelineImageBarrier                    (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask = 0u) const;
 513         de::MovePtr<TextureLevelPyramid>        readImage                                               (VkImageAspectFlags aspectMask, deUint32 baseLayer) const;
 514         tcu::TestStatus                                         verifyResultImage                               (const std::string& successMessage, const UVec4& clearCoords = UVec4()) const;
 515
 516 protected:
 517         enum ViewType
 518         {
 519                 VIEW_TYPE_SINGLE,
 520                 VIEW_TYPE_ARRAY,
 521                 VIEW_TYPE_CUBE
 522         };
 523         VkImageViewType                                         getCorrespondingImageViewType   (VkImageType imageType, ViewType viewType) const;
 524         VkImageUsageFlags                                       getImageUsageFlags                              (VkFormat format) const;
 525         VkImageAspectFlags                                      getImageAspectFlags                             (VkFormat format) const;
 526         bool                                                            getIsAttachmentFormat                   (VkFormat format, VkImageTiling tiling) const;
 527         bool                                                            getIsStencilFormat                              (VkFormat format) const;
 528         bool                                                            getIsDepthFormat                                (VkFormat format) const;
 529         VkImageFormatProperties                         getImageFormatProperties                (void) const;
 530         VkImageCreateFlags                                      getImageCreateFlags                             (void) const;
 531         ViewType                                                        getViewType                                             (deUint32 imageLayerCount) const;
 532         de::MovePtr<Allocation>                         allocateAndBindImageMemory              (VkImage image) const;
 533
 534         const TestParams&                                       m_params;
 535         const VkDevice                                          m_device;
 536         const InstanceInterface&                        m_vki;
 537         const DeviceInterface&                          m_vkd;
 538         const VkQueue                                           m_queue;
 539         const deUint32                                          m_queueFamilyIndex;
 540         Allocator&                                                      m_allocator;
 541
 542         const bool                                                      m_isAttachmentFormat;
 543         const VkImageUsageFlags                         m_imageUsageFlags;
 544         const VkImageAspectFlags                        m_imageAspectFlags;
 545         const VkImageFormatProperties           m_imageFormatProperties;
 546         const deUint32                                          m_imageMipLevels;
 547         const deUint32                                          m_thresholdMipLevel;
 548
 549         Unique<VkCommandPool>                           m_commandPool;
 550         Unique<VkCommandBuffer>                         m_commandBuffer;
 551
 552         Unique<VkImage>                                         m_image;
 553         de::MovePtr<Allocation>                         m_imageMemory;
 554         Unique<VkImageView>                                     m_imageView;
 555         Unique<VkRenderPass>                            m_renderPass;
 556         Unique<VkFramebuffer>                           m_frameBuffer;
 557 };
 558
 559 ImageClearingTestInstance::ImageClearingTestInstance (Context& context, const TestParams& params)
 560         : TestInstance                          (context)
 561         , m_params                                      (params)
 562         , m_device                                      (context.getDevice())
 563         , m_vki                                         (context.getInstanceInterface())
 564         , m_vkd                                         (context.getDeviceInterface())
 565         , m_queue                                       (context.getUniversalQueue())
 566         , m_queueFamilyIndex            (context.getUniversalQueueFamilyIndex())
 567         , m_allocator                           (context.getDefaultAllocator())
 568         , m_isAttachmentFormat          (getIsAttachmentFormat(params.imageFormat, params.imageTiling))
 569         , m_imageUsageFlags                     (getImageUsageFlags(params.imageFormat))
 570         , m_imageAspectFlags            (getImageAspectFlags(params.imageFormat))
 571         , m_imageFormatProperties       (getImageFormatProperties())
 572         , m_imageMipLevels                      (params.useSingleMipLevel ? 1u : getNumMipLevels(params.imageExtent, m_imageFormatProperties.maxMipLevels))
 573         , m_thresholdMipLevel           (std::max(m_imageMipLevels / 2u, 1u))
 574         , m_commandPool                         (createCommandPool(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT))
 575         , m_commandBuffer                       (allocatePrimaryCommandBuffer(*m_commandPool))
 576
 577         , m_image                                       (createImage(params.imageType,
 578                                                                                          params.imageFormat,
 579                                                                                          params.imageTiling,
 580                                                                                          params.imageExtent,
 581                                                                                          params.imageLayerCount,
 582                                                                                          m_imageUsageFlags))
 583
 584         , m_imageMemory                         (allocateAndBindImageMemory(*m_image))
 585         , m_imageView                           (m_isAttachmentFormat ? createImageView(*m_image,
 586                                                                                                  getCorrespondingImageViewType(params.imageType, getViewType(params.imageLayerCount)),
 587                                                                                                  params.imageFormat,
 588                                                                                                  m_imageAspectFlags,
 589                                                                                                  params.imageViewLayerRange) : vk::Move<VkImageView>())
 590
 591         , m_renderPass                          (m_isAttachmentFormat ? createRenderPass(params.imageFormat) : vk::Move<vk::VkRenderPass>())
 592         , m_frameBuffer                         (m_isAttachmentFormat ? createFrameBuffer(*m_imageView, *m_renderPass, params.imageExtent.width, params.imageExtent.height, params.imageViewLayerRange.layerCount) : vk::Move<vk::VkFramebuffer>())
 593 {
 594         if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
 595                 context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
 596
 597         if (m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
 598                 context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
 599 }
 600
 601 ImageClearingTestInstance::ViewType ImageClearingTestInstance::getViewType (deUint32 imageLayerCount) const
 602 {
 603         if (imageLayerCount > 1u)
 604                 return m_params.isCube ? VIEW_TYPE_CUBE : VIEW_TYPE_ARRAY;
 605         else
 606                 return VIEW_TYPE_SINGLE;
 607 }
 608
 609 VkImageViewType ImageClearingTestInstance::getCorrespondingImageViewType (VkImageType imageType, ViewType viewType) const
 610 {
 611         switch (imageType)
 612         {
 613         case VK_IMAGE_TYPE_1D:
 614                 return (viewType == VIEW_TYPE_ARRAY) ?  VK_IMAGE_VIEW_TYPE_1D_ARRAY : VK_IMAGE_VIEW_TYPE_1D;
 615         case VK_IMAGE_TYPE_2D:
 616                 if (viewType == VIEW_TYPE_ARRAY)
 617                         return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 618                 else if (viewType == VIEW_TYPE_CUBE)
 619                         return VK_IMAGE_VIEW_TYPE_CUBE;
 620                 else
 621                         return VK_IMAGE_VIEW_TYPE_2D;
 622         case VK_IMAGE_TYPE_3D:
 623                 if (viewType != VIEW_TYPE_SINGLE)
 624                 {
 625                         DE_FATAL("Cannot have 3D image array");
 626                 }
 627                 return VK_IMAGE_VIEW_TYPE_3D;
 628         default:
 629                 DE_FATAL("Unknown image type!");
 630         }
 631
 632         return VK_IMAGE_VIEW_TYPE_2D;
 633 }
 634
 635 VkImageUsageFlags ImageClearingTestInstance::getImageUsageFlags (VkFormat format) const
 636 {
 637         VkImageUsageFlags       commonFlags     = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 638
 639         if (m_isAttachmentFormat)
 640         {
 641                 if (isDepthStencilFormat(format))
 642                         return commonFlags | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 643
 644                 return commonFlags | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 645         }
 646         return commonFlags;
 647 }
 648
 649 VkImageAspectFlags ImageClearingTestInstance::getImageAspectFlags (VkFormat format) const
 650 {
 651         VkImageAspectFlags      imageAspectFlags        = 0;
 652
 653         if (getIsDepthFormat(format))
 654                 imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
 655
 656         if (getIsStencilFormat(format))
 657                 imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
 658
 659         if (imageAspectFlags == 0)
 660                 imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
 661
 662         return imageAspectFlags;
 663 }
 664
 665 bool ImageClearingTestInstance::getIsAttachmentFormat (VkFormat format, VkImageTiling tiling) const
 666 {
 667         const VkFormatProperties props          = vk::getPhysicalDeviceFormatProperties(m_vki, m_context.getPhysicalDevice(), format);
 668         const VkFormatFeatureFlags features     = tiling == VK_IMAGE_TILING_OPTIMAL ? props.optimalTilingFeatures : props.linearTilingFeatures;
 669
 670         return (features & (vk::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) != 0;
 671 }
 672
 673 bool ImageClearingTestInstance::getIsStencilFormat (VkFormat format) const
 674 {
 675         const TextureFormat tcuFormat   = mapVkFormat(format);
 676
 677         if (tcuFormat.order == TextureFormat::S || tcuFormat.order == TextureFormat::DS)
 678                 return true;
 679
 680         return false;
 681 }
 682
 683 bool ImageClearingTestInstance::getIsDepthFormat (VkFormat format) const
 684 {
 685         const TextureFormat     tcuFormat       = mapVkFormat(format);
 686
 687         if (tcuFormat.order == TextureFormat::D || tcuFormat.order == TextureFormat::DS)
 688                 return true;
 689
 690         return false;
 691 }
 692
 693 VkImageCreateFlags ImageClearingTestInstance::getImageCreateFlags (void) const
 694 {
 695         return m_params.isCube ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : (VkImageCreateFlags)0;
 696 }
 697
 698 VkImageFormatProperties ImageClearingTestInstance::getImageFormatProperties (void) const
 699 {
 700         VkImageFormatProperties properties;
 701         const VkResult result = m_vki.getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(), m_params.imageFormat, m_params.imageType,
 702                                                                                                                                                  m_params.imageTiling, m_imageUsageFlags, getImageCreateFlags(), &properties);
 703
 704         if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
 705                 TCU_THROW(NotSupportedError, "Format not supported");
 706         else
 707                 return properties;
 708 }
 709
 710 de::MovePtr<Allocation> ImageClearingTestInstance::allocateAndBindImageMemory (VkImage image) const
 711 {
 712         de::MovePtr<Allocation> imageMemory     (allocateImage(m_vki, m_vkd, m_context.getPhysicalDevice(), m_device, image, MemoryRequirement::Any, m_allocator, m_params.allocationKind));
 713         VK_CHECK(m_vkd.bindImageMemory(m_device, image, imageMemory->getMemory(), imageMemory->getOffset()));
 714         return imageMemory;
 715 }
 716
 717 Move<VkCommandPool> ImageClearingTestInstance::createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const
 718 {
 719         return vk::createCommandPool(m_vkd, m_device, commandPoolCreateFlags, m_queueFamilyIndex);
 720 }
 721
 722 Move<VkCommandBuffer> ImageClearingTestInstance::allocatePrimaryCommandBuffer (VkCommandPool commandPool) const
 723 {
 724         return vk::allocateCommandBuffer(m_vkd, m_device, commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 725 }
 726
 727 Move<VkImage> ImageClearingTestInstance::createImage (VkImageType imageType, VkFormat format, VkImageTiling tiling, VkExtent3D extent, deUint32 arrayLayerCount, VkImageUsageFlags usage) const
 728 {
 729         if (arrayLayerCount > m_imageFormatProperties.maxArrayLayers)
 730                 TCU_THROW(NotSupportedError, "Device does not support enough image array layers");
 731
 732         const VkImageCreateInfo                                 imageCreateInfo                 =
 733         {
 734                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,            // VkStructureType                      sType;
 735                 DE_NULL,                                                                        // const void*                          pNext;
 736                 getImageCreateFlags(),                                          // VkImageCreateFlags           flags;
 737                 imageType,                                                                      // VkImageType                          imageType;
 738                 format,                                                                         // VkFormat                                     format;
 739                 extent,                                                                         // VkExtent3D                           extent;
 740                 m_imageMipLevels,                                                       // deUint32                                     mipLevels;
 741                 arrayLayerCount,                                                        // deUint32                                     arrayLayers;
 742                 VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits        samples;
 743                 tiling,                                                                         // VkImageTiling                        tiling;
 744                 usage,                                                                          // VkImageUsageFlags            usage;
 745                 VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                        sharingMode;
 746                 1u,                                                                                     // deUint32                                     queueFamilyIndexCount;
 747                 &m_queueFamilyIndex,                                            // const deUint32*                      pQueueFamilyIndices;
 748                 VK_IMAGE_LAYOUT_UNDEFINED                                       // VkImageLayout                        initialLayout;
 749         };
 750
 751         return vk::createImage(m_vkd, m_device, &imageCreateInfo, DE_NULL);
 752 }
 753
 754 Move<VkImageView> ImageClearingTestInstance::createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask, LayerRange layerRange) const
 755 {
 756         const VkImageViewCreateInfo                             imageViewCreateInfo             =
 757         {
 758                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                              sType;
 759                 DE_NULL,                                                                        // const void*                                  pNext;
 760                 0u,                                                                                     // VkImageViewCreateFlags               flags;
 761                 image,                                                                          // VkImage                                              image;
 762                 viewType,                                                                       // VkImageViewType                              viewType;
 763                 format,                                                                         // VkFormat                                             format;
 764                 {
 765                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   r;
 766                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   g;
 767                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   b;
 768                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   a;
 769                 },                                                                                      // VkComponentMapping                   components;
 770                 {
 771                         aspectMask,                                                                     // VkImageAspectFlags                   aspectMask;
 772                         0u,                                                                                     // deUint32                                             baseMipLevel;
 773                         1u,                                                                                     // deUint32                                             mipLevels;
 774                         layerRange.baseArrayLayer,                                      // deUint32                                             baseArrayLayer;
 775                         layerRange.layerCount,                                          // deUint32                                             arraySize;
 776                 },                                                                                              // VkImageSubresourceRange              subresourceRange;
 777         };
 778
 779         return vk::createImageView(m_vkd, m_device, &imageViewCreateInfo, DE_NULL);
 780 }
 781
 782 Move<VkRenderPass> ImageClearingTestInstance::createRenderPass (VkFormat format) const
 783 {
 784         if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
 785         {
 786                 VkImageLayout                                                   imageLayout;
 787
 788                 if (isDepthStencilFormat(format))
 789                         imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 790                 else
 791                         imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 792
 793                 const VkAttachmentDescription                   attachmentDesc                  =
 794                 {
 795                         0u,                                                                                                     // VkAttachmentDescriptionFlags         flags;
 796                         format,                                                                                         // VkFormat                                                     format;
 797                         VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 798                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 799                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 800                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           stencilLoadOp;
 801                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          stencilStoreOp;
 802                         imageLayout,                                                                            // VkImageLayout                                        initialLayout;
 803                         imageLayout,                                                                            // VkImageLayout                                        finalLayout;
 804                 };
 805
 806                 const VkAttachmentDescription                   attachments[1]                  =
 807                 {
 808                         attachmentDesc
 809                 };
 810
 811                 const VkAttachmentReference                             attachmentRef                   =
 812                 {
 813                         0u,                                                                                                     // deUint32                                                     attachment;
 814                         imageLayout,                                                                            // VkImageLayout                                        layout;
 815                 };
 816
 817                 const VkAttachmentReference*                    pColorAttachments               = DE_NULL;
 818                 const VkAttachmentReference*                    pDepthStencilAttachment = DE_NULL;
 819                 deUint32                                                                colorAttachmentCount    = 1;
 820
 821                 if (isDepthStencilFormat(format))
 822                 {
 823                         colorAttachmentCount    = 0;
 824                         pDepthStencilAttachment = &attachmentRef;
 825                 }
 826                 else
 827                 {
 828                         colorAttachmentCount    = 1;
 829                         pColorAttachments               = &attachmentRef;
 830                 }
 831
 832                 const VkSubpassDescription                              subpassDesc[1]                  =
 833                 {
 834                         {
 835                                 0u,                                                                                             // VkSubpassDescriptionFlags            flags;
 836                                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                // VkPipelineBindPoint                          pipelineBindPoint;
 837                                 0u,                                                                                             // deUint32                                                     inputAttachmentCount;
 838                                 DE_NULL,                                                                                // const VkAttachmentReference*         pInputAttachments;
 839                                 colorAttachmentCount,                                                   // deUint32                                                     colorAttachmentCount;
 840                                 pColorAttachments,                                                              // const VkAttachmentReference*         pColorAttachments;
 841                                 DE_NULL,                                                                                // const VkAttachmentReference*         pResolveAttachments;
 842                                 pDepthStencilAttachment,                                                // const VkAttachmentReference*         pDepthStencilAttachment;
 843                                 0u,                                                                                             // deUint32                                                     preserveAttachmentCount;
 844                                 DE_NULL,                                                                                // const VkAttachmentReference*         pPreserveAttachments;
 845                         }
 846                 };
 847
 848                 const VkRenderPassCreateInfo                    renderPassCreateInfo    =
 849                 {
 850                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                      // VkStructureType                                      sType;
 851                         DE_NULL,                                                                                        // const void*                                          pNext;
 852                         0u,                                                                                                     // VkRenderPassCreateFlags                      flags;
 853                         1u,                                                                                                     // deUint32                                                     attachmentCount;
 854                         attachments,                                                                            // const VkAttachmentDescription*       pAttachments;
 855                         1u,                                                                                                     // deUint32                                                     subpassCount;
 856                         subpassDesc,                                                                            // const VkSubpassDescription*          pSubpasses;
 857                         0u,                                                                                                     // deUint32                                                     dependencyCount;
 858                         DE_NULL,                                                                                        // const VkSubpassDependency*           pDependencies;
 859                 };
 860
 861                 return vk::createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
 862         }
 863         else
 864         {
 865                 // Make sure VK_KHR_create_renderpass2 is supported. Due to InstanceFactory1 being used and the render pass being created in
 866                 // the instance constructor and not every time, this is the best moment to check.
 867                 m_context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
 868
 869                 VkImageLayout                                                           initialLayout                   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 870                 VkImageLayout                                                           finalLayout                             = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 871                 VkAttachmentDescriptionStencilLayoutKHR         stencilLayouts                  =
 872                 {
 873                         VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
 874                         DE_NULL,
 875                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
 876                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
 877                 };
 878
 879                 VkImageLayout                                                           imageLayout;
 880                 VkAttachmentReferenceStencilLayoutKHR           stencilLayoutRef                =
 881                 {
 882                         VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
 883                         DE_NULL,
 884                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
 885                 };
 886
 887                 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
 888                 {
 889                         initialLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
 890                         finalLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
 891                         stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 892                         stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_GENERAL;
 893                         imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
 894                         stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_GENERAL;
 895                 }
 896                 else
 897                 {
 898                         initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 899                         finalLayout = VK_IMAGE_LAYOUT_GENERAL;
 900                         stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 901                         stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
 902                         imageLayout = VK_IMAGE_LAYOUT_GENERAL;
 903                         stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
 904                 }
 905
 906                 const VkAttachmentDescription2KHR                       attachmentDesc                  =
 907                 {
 908                         VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,         // VkStructureType                                      sType;
 909                         &stencilLayouts,                                                                        // const void*                                          pNext;
 910                         0u,                                                                                                     // VkAttachmentDescriptionFlags         flags;
 911                         format,                                                                                         // VkFormat                                                     format;
 912                         VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 913                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 914                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 915                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           stencilLoadOp;
 916                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          stencilStoreOp;
 917                         initialLayout,                                                                          // VkImageLayout                                        initialLayout;
 918                         finalLayout,                                                                            // VkImageLayout                                        finalLayout;
 919                 };
 920
 921                 const VkAttachmentReference2KHR                         attachmentRef                   =
 922                 {
 923                         VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,           // VkStructureType              sType;
 924                         &stencilLayoutRef,                                                                      // const void*                  pNext;
 925                         0u,                                                                                                     // deUint32                             attachment;
 926                         imageLayout,                                                                            // VkImageLayout                layout;
 927                         0u,                                                                                                     // VkImageAspectFlags   aspectMask;
 928                 };
 929
 930                 const VkSubpassDescription2KHR                          subpassDesc                     =
 931                 {
 932                         VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR,    // VkStructureType                                      sType;
 933                         DE_NULL,                                                                                // const void*                                          pNext;
 934                         0u,                                                                                             // VkSubpassDescriptionFlags            flags;
 935                         VK_PIPELINE_BIND_POINT_GRAPHICS,                                // VkPipelineBindPoint                          pipelineBindPoint;
 936                         0u,                                                                                             // deUint32                                                     viewMask;
 937                         0u,                                                                                             // deUint32                                                     inputAttachmentCount;
 938                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pInputAttachments;
 939                         0u,                                                                                             // deUint32                                                     colorAttachmentCount;
 940                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pColorAttachments;
 941                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pResolveAttachments;
 942                         &attachmentRef,                                                                 // const VkAttachmentReference2KHR*     pDepthStencilAttachment;
 943                         0u,                                                                                             // deUint32                                                     preserveAttachmentCount;
 944                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pPreserveAttachments;
 945                 };
 946
 947                 const VkRenderPassCreateInfo2KHR                        renderPassCreateInfo    =
 948                 {
 949                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR,        // VkStructureType                                      sType;
 950                         DE_NULL,                                                                                        // const void*                                          pNext;
 951                         0u,                                                                                                     // VkRenderPassCreateFlags                      flags;
 952                         1u,                                                                                                     // deUint32                                                     attachmentCount;
 953                         &attachmentDesc,                                                                        // const VkAttachmentDescription*       pAttachments;
 954                         1u,                                                                                                     // deUint32                                                     subpassCount;
 955                         &subpassDesc,                                                                           // const VkSubpassDescription*          pSubpasses;
 956                         0u,                                                                                                     // deUint32                                                     dependencyCount;
 957                         DE_NULL,                                                                                        // const VkSubpassDependency*           pDependencies;
 958                         0u,                                                                                                     // deUint32                                                     correlatedViewMaskCount;
 959                         DE_NULL,                                                                                        // const deUint32*                                      pCorrelatedViewMasks;
 960                 };
 961
 962                 return vk::createRenderPass2(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
 963         }
 964 }
 965
 966 Move<VkFramebuffer> ImageClearingTestInstance::createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight, deUint32 imageLayersCount) const
 967 {
 968         const VkImageView                                               attachmentViews[1]              =
 969         {
 970                 imageView
 971         };
 972
 973         const VkFramebufferCreateInfo                   framebufferCreateInfo   =
 974         {
 975                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,      // VkStructureType                      sType;
 976                 DE_NULL,                                                                        // const void*                          pNext;
 977                 0u,                                                                                     // VkFramebufferCreateFlags     flags;
 978                 renderPass,                                                                     // VkRenderPass                         renderPass;
 979                 1,                                                                                      // deUint32                                     attachmentCount;
 980                 attachmentViews,                                                        // const VkImageView*           pAttachments;
 981                 imageWidth,                                                                     // deUint32                                     width;
 982                 imageHeight,                                                            // deUint32                                     height;
 983                 imageLayersCount,                                                       // deUint32                                     layers;
 984         };
 985
 986         return createFramebuffer(m_vkd, m_device, &framebufferCreateInfo, DE_NULL);
 987 }
 988
 989 void ImageClearingTestInstance::beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const
 990 {
 991         vk::beginCommandBuffer(m_vkd, *m_commandBuffer, usageFlags);
 992 }
 993
 994 void ImageClearingTestInstance::endCommandBuffer (void) const
 995 {
 996         vk::endCommandBuffer(m_vkd, *m_commandBuffer);
 997 }
 998
 999 void ImageClearingTestInstance::submitCommandBuffer (void) const
1000 {
1001         submitCommandsAndWait(m_vkd, m_device, m_queue, m_commandBuffer.get());
1002 }
1003
1004 void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask) const
1005 {
1006         if (!aspectMask || m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
1007                 aspectMask = m_imageAspectFlags;
1008
1009         const VkImageMemoryBarrier              imageBarrier    =
1010         {
1011                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1012                 DE_NULL,                                                                        // const void*                          pNext;
1013                 srcAccessMask,                                                          // VkAccessFlags                        srcAccessMask;
1014                 dstAccessMask,                                                          // VkAccessFlags                        dstAccessMask;
1015                 oldLayout,                                                                      // VkImageLayout                        oldLayout;
1016                 newLayout,                                                                      // VkImageLayout                        newLayout;
1017                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1018                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     destQueueFamilyIndex;
1019                 *m_image,                                                                       // VkImage                                      image;
1020                 {
1021                         aspectMask,                                                                     // VkImageAspectFlags   aspectMask;
1022                         0u,                                                                                     // deUint32                             baseMipLevel;
1023                         VK_REMAINING_MIP_LEVELS,                                        // deUint32                             levelCount;
1024                         0u,                                                                                     // deUint32                             baseArrayLayer;
1025                         VK_REMAINING_ARRAY_LAYERS,                                      // deUint32                             layerCount;
1026                 },                                                                                      // VkImageSubresourceRange      subresourceRange;
1027         };
1028
1029         m_vkd.cmdPipelineBarrier(*m_commandBuffer, srcStageMask, dstStageMask, 0, 0, DE_NULL, 0, DE_NULL, 1, &imageBarrier);
1030 }
1031
1032 de::MovePtr<TextureLevelPyramid> ImageClearingTestInstance::readImage (VkImageAspectFlags aspectMask, deUint32 arrayLayer) const
1033 {
1034         const TextureFormat                                     tcuFormat               = aspectMask == VK_IMAGE_ASPECT_COLOR_BIT ? mapVkFormat(m_params.imageFormat) :
1035                                                                                                                   aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT ? getDepthCopyFormat(m_params.imageFormat) :
1036                                                                                                                   aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT ? getStencilCopyFormat(m_params.imageFormat) :
1037                                                                                                                   TextureFormat();
1038         const deUint32                                          pixelSize               = getPixelSize(tcuFormat);
1039         deUint32                                                        alignment               = 4;    // subsequent mip levels aligned to 4 bytes
1040
1041         if (!getIsDepthFormat(m_params.imageFormat) && !getIsStencilFormat(m_params.imageFormat))
1042                 alignment = lowestCommonMultiple(pixelSize, alignment); // alignment must be multiple of pixel size, if not D/S.
1043
1044         const std::vector<deUint32>                     mipLevelSizes   = getImageMipLevelSizes(pixelSize, m_params.imageExtent, m_imageMipLevels, alignment);
1045         const VkDeviceSize                                      imageTotalSize  = std::accumulate(mipLevelSizes.begin(), mipLevelSizes.end(), 0u);
1046
1047         de::MovePtr<TextureLevelPyramid>        result                  (new TextureLevelPyramid(tcuFormat, m_imageMipLevels));
1048         Move<VkBuffer>                                          buffer;
1049         de::MovePtr<Allocation>                         bufferAlloc;
1050
1051         // Create destination buffer
1052         {
1053                 const VkBufferCreateInfo        bufferParams    =
1054                 {
1055                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
1056                         DE_NULL,                                                                        // const void*                  pNext;
1057                         0u,                                                                                     // VkBufferCreateFlags  flags;
1058                         imageTotalSize,                                                         // VkDeviceSize                 size;
1059                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
1060                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
1061                         0u,                                                                                     // deUint32                             queueFamilyIndexCount;
1062                         DE_NULL                                                                         // const deUint32*              pQueueFamilyIndices;
1063                 };
1064
1065                 buffer          = createBuffer(m_vkd, m_device, &bufferParams);
1066                 bufferAlloc     = allocateBuffer(m_vki, m_vkd, m_context.getPhysicalDevice(), m_device, *buffer, MemoryRequirement::HostVisible, m_allocator, m_params.allocationKind);
1067                 VK_CHECK(m_vkd.bindBufferMemory(m_device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
1068         }
1069
1070         // Barriers for copying image to buffer
1071
1072         const VkBufferMemoryBarrier             bufferBarrier   =
1073         {
1074                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
1075                 DE_NULL,                                                                        // const void*          pNext;
1076                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
1077                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
1078                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
1079                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
1080                 *buffer,                                                                        // VkBuffer                     buffer;
1081                 0u,                                                                                     // VkDeviceSize         offset;
1082                 imageTotalSize,                                                         // VkDeviceSize         size;
1083         };
1084
1085         // Copy image to buffer
1086         std::vector<VkBufferImageCopy> copyRegions;
1087         {
1088                 deUint32 offset = 0u;
1089                 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1090                 {
1091                         const VkExtent3D                extent  = getMipLevelExtent(m_params.imageExtent, mipLevel);
1092                         const VkBufferImageCopy region  =
1093                         {
1094                                 offset,                                                                         // VkDeviceSize                         bufferOffset;
1095                                 0u,                                                                                     // deUint32                                     bufferRowLength;
1096                                 0u,                                                                                     // deUint32                                     bufferImageHeight;
1097                                 { aspectMask, mipLevel, arrayLayer, 1u },       // VkImageSubresourceLayers     imageSubresource;
1098                                 { 0, 0, 0 },                                                            // VkOffset3D                           imageOffset;
1099                                 extent                                                                          // VkExtent3D                           imageExtent;
1100                         };
1101                         copyRegions.push_back(region);
1102                         offset += mipLevelSizes[mipLevel];
1103                 }
1104         }
1105
1106         beginCommandBuffer(0);
1107
1108         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
1109                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,
1110                                                  VK_ACCESS_TRANSFER_WRITE_BIT,
1111                                                  VK_ACCESS_TRANSFER_READ_BIT,
1112                                                  VK_IMAGE_LAYOUT_GENERAL,
1113                                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1114                                                  aspectMask);
1115
1116         m_vkd.cmdCopyImageToBuffer(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, static_cast<deUint32>(copyRegions.size()), &copyRegions[0]);
1117         m_vkd.cmdPipelineBarrier(*m_commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1118
1119         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
1120                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,
1121                                                  VK_ACCESS_TRANSFER_READ_BIT,
1122                                                  VK_ACCESS_TRANSFER_READ_BIT,
1123                                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1124                                                  VK_IMAGE_LAYOUT_GENERAL,
1125                                                  aspectMask);
1126
1127         endCommandBuffer();
1128         submitCommandBuffer();
1129
1130         invalidateAlloc(m_vkd, m_device, *bufferAlloc);
1131
1132         {
1133                 deUint32 offset = 0u;
1134                 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1135                 {
1136                         const VkExtent3D        extent          = getMipLevelExtent(m_params.imageExtent, mipLevel);
1137                         const void*                     pLevelData      = static_cast<const void*>(reinterpret_cast<deUint8*>(bufferAlloc->getHostPtr()) + offset);
1138
1139                         result->allocLevel(mipLevel, extent.width, extent.height, extent.depth);
1140                         copy(result->getLevel(mipLevel), ConstPixelBufferAccess(result->getFormat(), result->getLevel(mipLevel).getSize(), pLevelData));
1141
1142                         offset += mipLevelSizes[mipLevel];
1143                 }
1144         }
1145
1146         return result;
1147 }
1148
1149 tcu::TestStatus ImageClearingTestInstance::verifyResultImage (const std::string& successMessage, const UVec4& clearCoords) const
1150 {
1151         DE_ASSERT((clearCoords == UVec4()) || m_params.imageExtent.depth == 1u);
1152
1153         if (getIsDepthFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1154         {
1155                 DE_ASSERT(m_imageMipLevels == 1u);
1156
1157                 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount; ++arrayLayer)
1158                 {
1159                         de::MovePtr<TextureLevelPyramid>        image                   = readImage(VK_IMAGE_ASPECT_DEPTH_BIT, arrayLayer);
1160                         std::string                                                     message;
1161                         float                                                           depthValue;
1162
1163                         for (deUint32 y = 0; y < m_params.imageExtent.height; ++y)
1164                         for (deUint32 x = 0; x < m_params.imageExtent.width; ++x)
1165                         {
1166                                 if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1167                                         depthValue = m_params.clearValue[0].depthStencil.depth;
1168                                 else
1169                                 if (isInInitialClearRange(m_isAttachmentFormat, 0u /* mipLevel */, arrayLayer, m_params.imageViewLayerRange))
1170                                 {
1171                                         depthValue = m_params.initValue.depthStencil.depth;
1172                                 }
1173                                 else
1174                                         continue;
1175
1176                                 if (!comparePixelToDepthClearValue(image->getLevel(0), x, y, depthValue, message))
1177                                         return TestStatus::fail("Depth value mismatch! " + message);
1178                         }
1179                 }
1180         }
1181
1182         if (getIsStencilFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1183         {
1184                 DE_ASSERT(m_imageMipLevels == 1u);
1185
1186                 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount; ++arrayLayer)
1187                 {
1188                         de::MovePtr<TextureLevelPyramid>        image                   = readImage(VK_IMAGE_ASPECT_STENCIL_BIT, arrayLayer);
1189                         std::string                                                     message;
1190                         deUint32                                                        stencilValue;
1191
1192                         for (deUint32 y = 0; y < m_params.imageExtent.height; ++y)
1193                         for (deUint32 x = 0; x < m_params.imageExtent.width; ++x)
1194                         {
1195                                 if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1196                                         stencilValue = m_params.clearValue[0].depthStencil.stencil;
1197                                 else
1198                                 if (isInInitialClearRange(m_isAttachmentFormat, 0u /* mipLevel */, arrayLayer, m_params.imageViewLayerRange))
1199                                 {
1200                                         stencilValue = m_params.initValue.depthStencil.stencil;
1201                                 }
1202                                 else
1203                                         continue;
1204
1205                                 if (!comparePixelToStencilClearValue(image->getLevel(0), x, y, stencilValue, message))
1206                                         return TestStatus::fail("Stencil value mismatch! " + message);
1207                         }
1208                 }
1209         }
1210
1211         if (!isDepthStencilFormat(m_params.imageFormat))
1212         {
1213                 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount; ++arrayLayer)
1214                 {
1215                         de::MovePtr<TextureLevelPyramid>        image                   = readImage(VK_IMAGE_ASPECT_COLOR_BIT, arrayLayer);
1216                         std::string                                                     message;
1217                         const VkClearColorValue*                        pColorValue;
1218
1219                         for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1220                         {
1221                                 const int                       clearColorNdx   = (mipLevel < m_thresholdMipLevel ? 0 : 1);
1222                                 const VkExtent3D        extent                  = getMipLevelExtent(m_params.imageExtent, mipLevel);
1223
1224                                 for (deUint32 z = 0; z < extent.depth;  ++z)
1225                                 for (deUint32 y = 0; y < extent.height; ++y)
1226                                 for (deUint32 x = 0; x < extent.width;  ++x)
1227                                 {
1228                                         if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1229                                                 pColorValue = &m_params.clearValue[clearColorNdx].color;
1230                                         else
1231                                         {
1232                                                 if (isInInitialClearRange(m_isAttachmentFormat, mipLevel, arrayLayer, m_params.imageViewLayerRange))
1233                                                 {
1234                                                         pColorValue = &m_params.initValue.color;
1235                                                 }
1236                                                 else
1237                                                         continue;
1238                                         }
1239                                         if (!comparePixelToColorClearValue(image->getLevel(mipLevel), x, y, z, *pColorValue, message))
1240                                                 return TestStatus::fail("Color value mismatch! " + message);
1241                                 }
1242                         }
1243                 }
1244         }
1245
1246         return TestStatus::pass(successMessage);
1247 }
1248
1249 void ImageClearingTestInstance::beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const
1250 {
1251         vk::beginRenderPass(m_vkd, *m_commandBuffer, *m_renderPass, *m_frameBuffer, makeRect2D(0, 0, m_params.imageExtent.width, m_params.imageExtent.height), clearValue, content);
1252 }
1253
1254 class ClearColorImageTestInstance : public ImageClearingTestInstance
1255 {
1256 public:
1257                                 ClearColorImageTestInstance     (Context& context, const TestParams& testParams, bool twoStep = false) : ImageClearingTestInstance (context, testParams), m_twoStep(twoStep) {}
1258         TestStatus      iterate                                         (void);
1259 protected:
1260         bool            m_twoStep;
1261 };
1262
1263 class TwoStepClearColorImageTestInstance : public ClearColorImageTestInstance
1264 {
1265 public:
1266         TwoStepClearColorImageTestInstance (Context& context, const TestParams& testParams) : ClearColorImageTestInstance(context, testParams, true) {}
1267 };
1268
1269 TestStatus ClearColorImageTestInstance::iterate (void)
1270 {
1271         std::vector<VkImageSubresourceRange> subresourceRanges;
1272         std::vector<VkImageSubresourceRange> steptwoRanges;
1273
1274         if (m_imageMipLevels == 1)
1275         {
1276                 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u,                                   1u,                                                     m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount));
1277                 steptwoRanges.push_back(        makeImageSubresourceRange(m_imageAspectFlags, 0u,                                       VK_REMAINING_MIP_LEVELS,        m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1278         }
1279         else
1280         {
1281                 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u,                                   m_thresholdMipLevel,            m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1282                 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, m_thresholdMipLevel,  VK_REMAINING_MIP_LEVELS,        m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1283                 steptwoRanges.push_back(        makeImageSubresourceRange(m_imageAspectFlags, 0u,                                       m_thresholdMipLevel,            m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1284                 steptwoRanges.push_back(        makeImageSubresourceRange(m_imageAspectFlags, m_thresholdMipLevel,      VK_REMAINING_MIP_LEVELS,        m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1285         }
1286
1287         beginCommandBuffer(0);
1288
1289         pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                         // VkPipelineStageFlags         srcStageMask
1290                                                  VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                    // VkPipelineStageFlags         dstStageMask
1291                                                  0,                                                                                             // VkAccessFlags                        srcAccessMask
1292                                                  (m_isAttachmentFormat
1293                                                         ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
1294                                                         : VK_ACCESS_TRANSFER_WRITE_BIT),                        // VkAccessFlags                        dstAccessMask
1295                                                  VK_IMAGE_LAYOUT_UNDEFINED,                                             // VkImageLayout                        oldLayout;
1296                                                  (m_isAttachmentFormat
1297                                                         ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
1298                                                         : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL));       // VkImageLayout                        newLayout;
1299
1300         if (m_isAttachmentFormat)
1301         {
1302                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1303                 endRenderPass(m_vkd, *m_commandBuffer);
1304
1305                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                // VkPipelineStageFlags         srcStageMask
1306                         VK_PIPELINE_STAGE_TRANSFER_BIT,                                                         // VkPipelineStageFlags         dstStageMask
1307                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                                           // VkAccessFlags                        srcAccessMask
1308                         VK_ACCESS_TRANSFER_WRITE_BIT,                                                           // VkAccessFlags                        dstAccessMask
1309                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                                       // VkImageLayout                        oldLayout;
1310                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);                                          // VkImageLayout                        newLayout;
1311         }
1312
1313         // Different clear color per range
1314         for (std::size_t i = 0u; i < subresourceRanges.size(); ++i)
1315         {
1316                 m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[i].color, 1, &subresourceRanges[i]);
1317                 if (m_twoStep)
1318                         m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[i].color, 1, &steptwoRanges[i]);
1319         }
1320
1321         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                            // VkPipelineStageFlags         srcStageMask
1322                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,                                // VkPipelineStageFlags         dstStageMask
1323                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                  // VkAccessFlags                        srcAccessMask
1324                                                  VK_ACCESS_TRANSFER_READ_BIT,                                   // VkAccessFlags                        dstAccessMask
1325                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                  // VkImageLayout                        oldLayout;
1326                                                  VK_IMAGE_LAYOUT_GENERAL);                                              // VkImageLayout                        newLayout;
1327
1328         endCommandBuffer();
1329         submitCommandBuffer();
1330
1331         return verifyResultImage("cmdClearColorImage passed");
1332 }
1333
1334 class ClearDepthStencilImageTestInstance : public ImageClearingTestInstance
1335 {
1336 public:
1337                                 ClearDepthStencilImageTestInstance      (Context& context, const TestParams& testParams, bool twoStep = false) : ImageClearingTestInstance (context, testParams), m_twoStep(twoStep) {}
1338         TestStatus      iterate                                                         (void);
1339 protected:
1340         bool            m_twoStep;
1341 };
1342
1343 class TwoStepClearDepthStencilImageTestInstance : public ClearDepthStencilImageTestInstance
1344 {
1345 public:
1346         TwoStepClearDepthStencilImageTestInstance (Context& context, const TestParams& testParams) : ClearDepthStencilImageTestInstance (context, testParams, true) { }
1347 };
1348
1349 TestStatus ClearDepthStencilImageTestInstance::iterate (void)
1350 {
1351         VkImageLayout           layout  = (m_isAttachmentFormat
1352                                                                         ?       VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
1353                                                                         :       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
1354         VkImageAspectFlags      aspectMask      = m_imageAspectFlags;
1355         if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1356         {
1357                 layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
1358                 aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1359         }
1360         else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1361         {
1362                 layout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
1363                 aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1364         }
1365
1366         const VkImageSubresourceRange subresourceRange  = makeImageSubresourceRange(aspectMask, 0u, 1u,                                                 m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount);
1367         const VkImageSubresourceRange steptwoRange              = makeImageSubresourceRange(aspectMask, 0u, VK_REMAINING_MIP_LEVELS,    m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS);
1368
1369         beginCommandBuffer(0);
1370
1371         pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                                 // VkPipelineStageFlags         srcStageMask
1372                                                  VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                            // VkPipelineStageFlags         dstStageMask
1373                                                  0,                                                                                                     // VkAccessFlags                        srcAccessMask
1374                                                  (m_isAttachmentFormat
1375                                                         ?       VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
1376                                                         :       VK_ACCESS_TRANSFER_WRITE_BIT),                          // VkAccessFlags                        dstAccessMask
1377                                                  VK_IMAGE_LAYOUT_UNDEFINED,                                                     // VkImageLayout                        oldLayout;
1378                                                  layout,                                                                                        // VkImageLayout                        newLayout;
1379                                                  aspectMask);                                                                           // VkImageAspectFlags           aspectMask;
1380
1381         if (m_isAttachmentFormat)
1382         {
1383                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1384                 endRenderPass(m_vkd, *m_commandBuffer);
1385
1386                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                                        // VkPipelineStageFlags         srcStageMask
1387                                                          VK_PIPELINE_STAGE_TRANSFER_BIT,                                                // VkPipelineStageFlags         dstStageMask
1388                                                          VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,                  // VkAccessFlags                        srcAccessMask
1389                                                          VK_ACCESS_TRANSFER_WRITE_BIT,                                                  // VkAccessFlags                        dstAccessMask
1390                                                          layout,                                                                                                // VkImageLayout                        oldLayout;
1391                                                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                                  // VkImageLayout                        newLayout;
1392                                                          aspectMask);                                                                                   // VkImageAspectFlags           aspectMask;
1393         }
1394
1395         m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &subresourceRange);
1396
1397         if (m_twoStep)
1398                 m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &steptwoRange);
1399
1400         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                                    // VkPipelineStageFlags         srcStageMask
1401                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,                                        // VkPipelineStageFlags         dstStageMask
1402                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                          // VkAccessFlags                        srcAccessMask
1403                                                  VK_ACCESS_TRANSFER_READ_BIT,                                           // VkAccessFlags                        dstAccessMask
1404                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                          // VkImageLayout                        oldLayout;
1405                                                  VK_IMAGE_LAYOUT_GENERAL,                                                       // VkImageLayout                        newLayout;
1406                                                  aspectMask);                                                                           // VkImageAspectFlags           aspectMask;
1407
1408         endCommandBuffer();
1409         submitCommandBuffer();
1410
1411         return verifyResultImage("cmdClearDepthStencilImage passed");
1412 }
1413
1414 class ClearAttachmentTestInstance : public ImageClearingTestInstance
1415 {
1416 public:
1417         enum ClearType
1418         {
1419                 FULL_CLEAR,
1420                 PARTIAL_CLEAR,
1421         };
1422
1423         ClearAttachmentTestInstance (Context& context, const TestParams& testParams, const ClearType clearType = FULL_CLEAR)
1424                 : ImageClearingTestInstance     (context, testParams)
1425                 , m_clearType                           (clearType)
1426         {
1427                 if (!m_isAttachmentFormat)
1428                         TCU_THROW(NotSupportedError, "Format not renderable");
1429         }
1430
1431         TestStatus iterate (void)
1432         {
1433                 const bool                      isDepthStencil          = isDepthStencilFormat(m_params.imageFormat);
1434                 const VkAccessFlags     accessMask                      = (isDepthStencil ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT     : VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
1435                 VkImageLayout           attachmentLayout        = (isDepthStencil ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
1436                 VkImageAspectFlags      aspectMask                      = m_imageAspectFlags;
1437
1438                 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1439                 {
1440                         attachmentLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
1441                         aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1442                 }
1443                 else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1444                 {
1445                         attachmentLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
1446                         aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1447                 }
1448
1449                 const VkClearAttachment clearAttachment =
1450                 {
1451                         aspectMask,                                                     // VkImageAspectFlags   aspectMask;
1452                         0u,                                                                     // deUint32                             colorAttachment;
1453                         m_params.clearValue[0]                          // VkClearValue                 clearValue;
1454                 };
1455
1456                 UVec4                                           clearCoords;
1457                 std::vector<VkClearRect>        clearRects;
1458
1459                 if (m_clearType == FULL_CLEAR)
1460                 {
1461                         const VkClearRect rect =
1462                         {
1463                                 {
1464                                         { 0, 0 },                                                                                                                                       // VkOffset2D    offset;
1465                                         { m_params.imageExtent.width, m_params.imageExtent.height }                                     // VkExtent2D    extent;
1466                                 },                                                                                                                                                      // VkRect2D     rect;
1467                                 m_params.clearLayerRange.baseArrayLayer,                                                                // deUint32     baseArrayLayer;
1468                                 m_params.clearLayerRange.layerCount,                                                                    // deUint32     layerCount;
1469                         };
1470
1471                         clearRects.push_back(rect);
1472                 }
1473                 else
1474                 {
1475                         const deUint32  clearX          = m_params.imageExtent.width  / 8u;
1476                         const deUint32  clearY          = m_params.imageExtent.height / 8u;
1477                         const deUint32  clearWidth      = m_params.imageExtent.width  / 2u;
1478                         const deUint32  clearHeight     = m_params.imageExtent.height / 2u;
1479
1480                         clearCoords     = UVec4(clearX,                                 clearY,
1481                                                                 clearX + clearWidth,    clearY + clearHeight);
1482
1483                         const VkClearRect rects[2] =
1484                         {
1485                                 {
1486                                         {
1487                                                 { 0,                                                    static_cast<deInt32>(clearY)    },              // VkOffset2D    offset;
1488                                                 { m_params.imageExtent.width,   clearHeight                                             }               // VkExtent2D    extent;
1489                                         },                                                                                                                                              // VkRect2D     rect;
1490                                         m_params.clearLayerRange.baseArrayLayer,                                                                // deUint32     baseArrayLayer;
1491                                         m_params.clearLayerRange.layerCount                                                                             // deUint32     layerCount;
1492                                 },
1493                                 {
1494                                         {
1495                                                 { static_cast<deInt32>(clearX), 0                                                       },                      // VkOffset2D    offset;
1496                                                 { clearWidth,                                   m_params.imageExtent.height     }                       // VkExtent2D    extent;
1497                                         },                                                                                                                                              // VkRect2D     rect;
1498                                         m_params.clearLayerRange.baseArrayLayer,                                                                // deUint32     baseArrayLayer;
1499                                         m_params.clearLayerRange.layerCount                                                                             // deUint32     layerCount;
1500                                 }
1501                         };
1502
1503                         clearRects.push_back(rects[0]);
1504                         clearRects.push_back(rects[1]);
1505                 }
1506
1507                 beginCommandBuffer(0);
1508
1509                 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                         // VkPipelineStageFlags         srcStageMask
1510                                                          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                    // VkPipelineStageFlags         dstStageMask
1511                                                          0,                                                                                             // VkAccessFlags                        srcAccessMask
1512                                                          accessMask,                                                                    // VkAccessFlags                        dstAccessMask
1513                                                          VK_IMAGE_LAYOUT_UNDEFINED,                                             // VkImageLayout                        oldLayout;
1514                                                          attachmentLayout,                                                              // VkImageLayout                        newLayout;
1515                                                          aspectMask);                                                                   // VkImageAspectFlags           aspectMask;
1516
1517                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1518                 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, static_cast<deUint32>(clearRects.size()), &clearRects[0]);
1519                 endRenderPass(m_vkd, *m_commandBuffer);
1520
1521                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                        // VkPipelineStageFlags         srcStageMask
1522                                                          VK_PIPELINE_STAGE_TRANSFER_BIT,                                // VkPipelineStageFlags         dstStageMask
1523                                                          accessMask,                                                                    // VkAccessFlags                        srcAccessMask
1524                                                          VK_ACCESS_TRANSFER_READ_BIT,                                   // VkAccessFlags                        dstAccessMask
1525                                                          attachmentLayout,                                                              // VkImageLayout                        oldLayout;
1526                                                          VK_IMAGE_LAYOUT_GENERAL,                                               // VkImageLayout                        newLayout;
1527                                                          aspectMask);                                                                   // VkImageAspectFlags           aspectMask;
1528
1529                 endCommandBuffer();
1530                 submitCommandBuffer();
1531
1532                 return verifyResultImage("cmdClearAttachments passed", clearCoords);
1533         }
1534
1535 private:
1536         const ClearType m_clearType;
1537 };
1538
1539 class PartialClearAttachmentTestInstance : public ClearAttachmentTestInstance
1540 {
1541 public:
1542         PartialClearAttachmentTestInstance (Context& context, const TestParams& testParams) : ClearAttachmentTestInstance (context, testParams, PARTIAL_CLEAR) {}
1543 };
1544
1545 VkClearValue makeClearColorValue (VkFormat format, float r, float g, float b, float a)
1546 {
1547         const   TextureFormat tcuFormat = mapVkFormat(format);
1548         VkClearValue clearValue;
1549
1550         if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_FLOATING_POINT
1551                 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
1552                 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
1553         {
1554                 clearValue.color.float32[0] = r;
1555                 clearValue.color.float32[1] = g;
1556                 clearValue.color.float32[2] = b;
1557                 clearValue.color.float32[3] = a;
1558         }
1559         else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
1560         {
1561                 UVec4 maxValues = getFormatMaxUintValue(tcuFormat);
1562
1563                 clearValue.color.uint32[0] = (deUint32)((float)maxValues[0] * r);
1564                 clearValue.color.uint32[1] = (deUint32)((float)maxValues[1] * g);
1565                 clearValue.color.uint32[2] = (deUint32)((float)maxValues[2] * b);
1566                 clearValue.color.uint32[3] = (deUint32)((float)maxValues[3] * a);
1567         }
1568         else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER)
1569         {
1570                 IVec4 maxValues = getFormatMaxIntValue(tcuFormat);
1571
1572                 clearValue.color.int32[0] = (deUint32)((float)maxValues[0] * r);
1573                 clearValue.color.int32[1] = (deUint32)((float)maxValues[1] * g);
1574                 clearValue.color.int32[2] = (deUint32)((float)maxValues[2] * b);
1575                 clearValue.color.int32[3] = (deUint32)((float)maxValues[3] * a);
1576         }
1577         else
1578                 DE_FATAL("Unknown channel class");
1579
1580         return clearValue;
1581 }
1582
1583 std::string getFormatCaseName (VkFormat format)
1584 {
1585         return de::toLower(de::toString(getFormatStr(format)).substr(10));
1586 }
1587
1588 const char* getImageTypeCaseName (VkImageType type)
1589 {
1590         const char* s_names[] =
1591         {
1592                 "1d",
1593                 "2d",
1594                 "3d"
1595         };
1596         return s_names[type];
1597 }
1598
1599 const char* getImageTilingCaseName (VkImageTiling tiling)
1600 {
1601         const char* s_names[] =
1602         {
1603                 "optimal",
1604                 "linear",
1605         };
1606         return s_names[tiling];
1607 }
1608
1609 TestCaseGroup* createImageClearingTestsCommon (TestContext& testCtx, tcu::TestCaseGroup* imageClearingTests, AllocationKind allocationKind)
1610 {
1611         de::MovePtr<TestCaseGroup>      colorImageClearTests                                    (new TestCaseGroup(testCtx, "clear_color_image", "Color Image Clear Tests"));
1612         de::MovePtr<TestCaseGroup>      depthStencilImageClearTests                             (new TestCaseGroup(testCtx, "clear_depth_stencil_image", "Color Depth/Stencil Image Tests"));
1613         de::MovePtr<TestCaseGroup>      colorAttachmentClearTests                               (new TestCaseGroup(testCtx, "clear_color_attachment", "Color Color Attachment Tests"));
1614         de::MovePtr<TestCaseGroup>      depthStencilAttachmentClearTests                (new TestCaseGroup(testCtx, "clear_depth_stencil_attachment", "Color Depth/Stencil Attachment Tests"));
1615         de::MovePtr<TestCaseGroup>      partialColorAttachmentClearTests                (new TestCaseGroup(testCtx, "partial_clear_color_attachment", "Clear Partial Color Attachment Tests"));
1616         de::MovePtr<TestCaseGroup>      partialDepthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_depth_stencil_attachment", "Clear Partial Depth/Stencil Attachment Tests"));
1617
1618         // Some formats are commented out due to the tcu::TextureFormat does not support them yet.
1619         const VkFormat          colorImageFormatsToTest[]       =
1620         {
1621                 VK_FORMAT_R4G4_UNORM_PACK8,
1622                 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
1623                 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
1624                 VK_FORMAT_R5G6B5_UNORM_PACK16,
1625                 VK_FORMAT_B5G6R5_UNORM_PACK16,
1626                 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
1627                 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
1628                 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
1629                 VK_FORMAT_R8_UNORM,
1630                 VK_FORMAT_R8_SNORM,
1631                 VK_FORMAT_R8_USCALED,
1632                 VK_FORMAT_R8_SSCALED,
1633                 VK_FORMAT_R8_UINT,
1634                 VK_FORMAT_R8_SINT,
1635                 VK_FORMAT_R8_SRGB,
1636                 VK_FORMAT_R8G8_UNORM,
1637                 VK_FORMAT_R8G8_SNORM,
1638                 VK_FORMAT_R8G8_USCALED,
1639                 VK_FORMAT_R8G8_SSCALED,
1640                 VK_FORMAT_R8G8_UINT,
1641                 VK_FORMAT_R8G8_SINT,
1642                 VK_FORMAT_R8G8_SRGB,
1643                 VK_FORMAT_R8G8B8_UNORM,
1644                 VK_FORMAT_R8G8B8_SNORM,
1645                 VK_FORMAT_R8G8B8_USCALED,
1646                 VK_FORMAT_R8G8B8_SSCALED,
1647                 VK_FORMAT_R8G8B8_UINT,
1648                 VK_FORMAT_R8G8B8_SINT,
1649                 VK_FORMAT_R8G8B8_SRGB,
1650                 VK_FORMAT_B8G8R8_UNORM,
1651                 VK_FORMAT_B8G8R8_SNORM,
1652                 VK_FORMAT_B8G8R8_USCALED,
1653                 VK_FORMAT_B8G8R8_SSCALED,
1654                 VK_FORMAT_B8G8R8_UINT,
1655                 VK_FORMAT_B8G8R8_SINT,
1656                 VK_FORMAT_B8G8R8_SRGB,
1657                 VK_FORMAT_R8G8B8A8_UNORM,
1658                 VK_FORMAT_R8G8B8A8_SNORM,
1659                 VK_FORMAT_R8G8B8A8_USCALED,
1660                 VK_FORMAT_R8G8B8A8_SSCALED,
1661                 VK_FORMAT_R8G8B8A8_UINT,
1662                 VK_FORMAT_R8G8B8A8_SINT,
1663                 VK_FORMAT_R8G8B8A8_SRGB,
1664                 VK_FORMAT_B8G8R8A8_UNORM,
1665                 VK_FORMAT_B8G8R8A8_SNORM,
1666                 VK_FORMAT_B8G8R8A8_USCALED,
1667                 VK_FORMAT_B8G8R8A8_SSCALED,
1668                 VK_FORMAT_B8G8R8A8_UINT,
1669                 VK_FORMAT_B8G8R8A8_SINT,
1670                 VK_FORMAT_B8G8R8A8_SRGB,
1671                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
1672                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
1673                 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
1674                 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
1675                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
1676                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
1677                 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
1678                 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
1679                 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
1680                 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
1681                 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
1682                 VK_FORMAT_A2R10G10B10_UINT_PACK32,
1683                 VK_FORMAT_A2R10G10B10_SINT_PACK32,
1684                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
1685                 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
1686                 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
1687                 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
1688                 VK_FORMAT_A2B10G10R10_UINT_PACK32,
1689                 VK_FORMAT_A2B10G10R10_SINT_PACK32,
1690                 VK_FORMAT_R16_UNORM,
1691                 VK_FORMAT_R16_SNORM,
1692                 VK_FORMAT_R16_USCALED,
1693                 VK_FORMAT_R16_SSCALED,
1694                 VK_FORMAT_R16_UINT,
1695                 VK_FORMAT_R16_SINT,
1696                 VK_FORMAT_R16_SFLOAT,
1697                 VK_FORMAT_R16G16_UNORM,
1698                 VK_FORMAT_R16G16_SNORM,
1699                 VK_FORMAT_R16G16_USCALED,
1700                 VK_FORMAT_R16G16_SSCALED,
1701                 VK_FORMAT_R16G16_UINT,
1702                 VK_FORMAT_R16G16_SINT,
1703                 VK_FORMAT_R16G16_SFLOAT,
1704                 VK_FORMAT_R16G16B16_UNORM,
1705                 VK_FORMAT_R16G16B16_SNORM,
1706                 VK_FORMAT_R16G16B16_USCALED,
1707                 VK_FORMAT_R16G16B16_SSCALED,
1708                 VK_FORMAT_R16G16B16_UINT,
1709                 VK_FORMAT_R16G16B16_SINT,
1710                 VK_FORMAT_R16G16B16_SFLOAT,
1711                 VK_FORMAT_R16G16B16A16_UNORM,
1712                 VK_FORMAT_R16G16B16A16_SNORM,
1713                 VK_FORMAT_R16G16B16A16_USCALED,
1714                 VK_FORMAT_R16G16B16A16_SSCALED,
1715                 VK_FORMAT_R16G16B16A16_UINT,
1716                 VK_FORMAT_R16G16B16A16_SINT,
1717                 VK_FORMAT_R16G16B16A16_SFLOAT,
1718                 VK_FORMAT_R32_UINT,
1719                 VK_FORMAT_R32_SINT,
1720                 VK_FORMAT_R32_SFLOAT,
1721                 VK_FORMAT_R32G32_UINT,
1722                 VK_FORMAT_R32G32_SINT,
1723                 VK_FORMAT_R32G32_SFLOAT,
1724                 VK_FORMAT_R32G32B32_UINT,
1725                 VK_FORMAT_R32G32B32_SINT,
1726                 VK_FORMAT_R32G32B32_SFLOAT,
1727                 VK_FORMAT_R32G32B32A32_UINT,
1728                 VK_FORMAT_R32G32B32A32_SINT,
1729                 VK_FORMAT_R32G32B32A32_SFLOAT,
1730 //              VK_FORMAT_R64_UINT,
1731 //              VK_FORMAT_R64_SINT,
1732 //              VK_FORMAT_R64_SFLOAT,
1733 //              VK_FORMAT_R64G64_UINT,
1734 //              VK_FORMAT_R64G64_SINT,
1735 //              VK_FORMAT_R64G64_SFLOAT,
1736 //              VK_FORMAT_R64G64B64_UINT,
1737 //              VK_FORMAT_R64G64B64_SINT,
1738 //              VK_FORMAT_R64G64B64_SFLOAT,
1739 //              VK_FORMAT_R64G64B64A64_UINT,
1740 //              VK_FORMAT_R64G64B64A64_SINT,
1741 //              VK_FORMAT_R64G64B64A64_SFLOAT,
1742                 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
1743                 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
1744 //              VK_FORMAT_BC1_RGB_UNORM_BLOCK,
1745 //              VK_FORMAT_BC1_RGB_SRGB_BLOCK,
1746 //              VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
1747 //              VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
1748 //              VK_FORMAT_BC2_UNORM_BLOCK,
1749 //              VK_FORMAT_BC2_SRGB_BLOCK,
1750 //              VK_FORMAT_BC3_UNORM_BLOCK,
1751 //              VK_FORMAT_BC3_SRGB_BLOCK,
1752 //              VK_FORMAT_BC4_UNORM_BLOCK,
1753 //              VK_FORMAT_BC4_SNORM_BLOCK,
1754 //              VK_FORMAT_BC5_UNORM_BLOCK,
1755 //              VK_FORMAT_BC5_SNORM_BLOCK,
1756 //              VK_FORMAT_BC6H_UFLOAT_BLOCK,
1757 //              VK_FORMAT_BC6H_SFLOAT_BLOCK,
1758 //              VK_FORMAT_BC7_UNORM_BLOCK,
1759 //              VK_FORMAT_BC7_SRGB_BLOCK,
1760 //              VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
1761 //              VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
1762 //              VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
1763 //              VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
1764 //              VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
1765 //              VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
1766 //              VK_FORMAT_EAC_R11_UNORM_BLOCK,
1767 //              VK_FORMAT_EAC_R11_SNORM_BLOCK,
1768 //              VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
1769 //              VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
1770 //              VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
1771 //              VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
1772 //              VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
1773 //              VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
1774 //              VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
1775 //              VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
1776 //              VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
1777 //              VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
1778 //              VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
1779 //              VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
1780 //              VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
1781 //              VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
1782 //              VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
1783 //              VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
1784 //              VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
1785 //              VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
1786 //              VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
1787 //              VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
1788 //              VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
1789 //              VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
1790 //              VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
1791 //              VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
1792 //              VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
1793 //              VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
1794 //              VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
1795 //              VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
1796 //              VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
1797 //              VK_FORMAT_ASTC_12x12_SRGB_BLOCK
1798         };
1799         const size_t    numOfColorImageFormatsToTest                    = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
1800
1801         const VkFormat  depthStencilImageFormatsToTest[]                =
1802         {
1803                 VK_FORMAT_D16_UNORM,
1804                 VK_FORMAT_X8_D24_UNORM_PACK32,
1805                 VK_FORMAT_D32_SFLOAT,
1806                 VK_FORMAT_S8_UINT,
1807                 VK_FORMAT_D16_UNORM_S8_UINT,
1808                 VK_FORMAT_D24_UNORM_S8_UINT,
1809                 VK_FORMAT_D32_SFLOAT_S8_UINT
1810         };
1811         const size_t    numOfDepthStencilImageFormatsToTest             = DE_LENGTH_OF_ARRAY(depthStencilImageFormatsToTest);
1812
1813         struct ImageLayerParams
1814         {
1815                 deUint32                imageLayerCount;
1816                 LayerRange              imageViewRange;
1817                 LayerRange              clearLayerRange;
1818                 bool                    twoStep;
1819                 const char*             testName;
1820                 bool                    isCube;
1821         };
1822         const ImageLayerParams imageLayerParamsToTest[] =
1823         {
1824                 {
1825                         1u,                                                                     // imageLayerCount
1826                         {0u, 1u},                                                       // imageViewRange
1827                         {0u, 1u},                                                       // clearLayerRange
1828                         false,                                                          // twoStep
1829                         "single_layer",                                         // testName
1830                         false                                                           // isCube
1831                 },
1832                 {
1833                         16u,                                                            // imageLayerCount
1834                         {3u, 12u},                                                      // imageViewRange
1835                         {2u, 5u},                                                       // clearLayerRange
1836                         false,                                                          // twoStep
1837                         "multiple_layers",                                      // testName
1838                         false                                                           // isCube
1839                 },
1840                 {
1841                         15u,                                                            // imageLayerCount
1842                         { 3u, 6u },                                                     // imageViewRange
1843                         { 2u, 1u },                                                     // clearLayerRange
1844                         false,                                                          // twoStep
1845                         "cube_layers",                                          // testName
1846                         true                                                            // isCube
1847                 },
1848                 {
1849                         16u,                                                            // imageLayerCount
1850                         { 3u, 12u },                                            // imageViewRange
1851                         { 8u, VK_REMAINING_ARRAY_LAYERS },      // clearLayerRange
1852                         false,                                                          // twoStep
1853                         "remaining_array_layers",                       // testName
1854                         false                                                           // isCube
1855                 },
1856                 {
1857                         16u,                                                            // imageLayerCount
1858                         { 3u, 12u },                                            // imageViewRange
1859                         { 8u, VK_REMAINING_ARRAY_LAYERS },      // clearLayerRange
1860                         true,                                                           // twoStep
1861                         "remaining_array_layers_twostep",       // testName
1862                         false                                                           // isCube
1863                 }
1864         };
1865
1866         // Include test cases with VK_REMAINING_ARRAY_LAYERS when using vkCmdClearColorImage
1867         const size_t            numOfImageLayerParamsToTest                     = DE_LENGTH_OF_ARRAY(imageLayerParamsToTest);
1868
1869         // Exclude test cases with VK_REMAINING_ARRAY_LAYERS when using vkCmdClearAttachments
1870         const size_t            numOfAttachmentLayerParamsToTest        = numOfImageLayerParamsToTest - 2;
1871
1872         const VkExtent3D        imageDimensions[]                                       =
1873         {
1874                 { 256,  1,              1},
1875                 { 256,  256,    1},
1876                 { 256,  256,    16},
1877                 { 200,  1,              1},
1878                 { 200,  180,    1},
1879                 { 200,  180,    16},
1880                 { 71,   1,              1},
1881                 { 1,    33,             1},
1882                 { 55,   21,             11},
1883                 { 64,   11,             1},
1884                 { 33,   128,    1},
1885                 { 32,   29,             3}
1886         };
1887
1888         // Clear color image
1889         {
1890                 const VkImageType                       imageTypesToTest[]              =
1891                 {
1892                         VK_IMAGE_TYPE_1D,
1893                         VK_IMAGE_TYPE_2D,
1894                         VK_IMAGE_TYPE_3D
1895                 };
1896                 const size_t                            numOfImageTypesToTest   = DE_LENGTH_OF_ARRAY(imageTypesToTest);
1897
1898                 const VkImageTiling                     imageTilingsToTest[]    =
1899                 {
1900                         VK_IMAGE_TILING_OPTIMAL,
1901                         VK_IMAGE_TILING_LINEAR,
1902                 };
1903                 const size_t                            numOfImageTilingsToTest = DE_LENGTH_OF_ARRAY(imageTilingsToTest);
1904
1905                 for (size_t     imageTypeIndex = 0; imageTypeIndex < numOfImageTypesToTest; ++imageTypeIndex)
1906                 {
1907                         de::MovePtr<TestCaseGroup> imageTypeGroup(new TestCaseGroup(testCtx, getImageTypeCaseName(imageTypesToTest[imageTypeIndex]), ""));
1908
1909                         for (size_t     imageTilingIndex = 0; imageTilingIndex < numOfImageTilingsToTest; ++imageTilingIndex)
1910                         {
1911                                 de::MovePtr<TestCaseGroup> imageTilingGroup(new TestCaseGroup(testCtx, getImageTilingCaseName(imageTilingsToTest[imageTilingIndex]), ""));
1912
1913                                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfImageLayerParamsToTest; ++imageLayerParamsIndex)
1914                                 {
1915                                         // 3D ARRAY images are not supported
1916                                         if (imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount > 1u && imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_3D)
1917                                                 continue;
1918
1919                                         // CUBE images are not tested in clear image tests (they are tested in clear attachment tests)
1920                                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube)
1921                                                 continue;
1922
1923                                         de::MovePtr<TestCaseGroup> imageLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
1924
1925                                         for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
1926                                         {
1927                                                 const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
1928                                                 const std::string       dimensionsString        = extentToString(dimensions, imageTypesToTest[imageTypeIndex]);
1929
1930                                                 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_1D && dimensions.height > 1)
1931                                                         continue;
1932                                                 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_2D && (dimensions.depth > 1 || dimensions.height == 1))
1933                                                         continue;
1934                                                 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_3D && dimensions.depth == 1)
1935                                                         continue;
1936
1937                                                 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
1938                                                 {
1939                                                         const VkFormat          format                  = colorImageFormatsToTest[imageFormatIndex];
1940                                                         const std::string       testCaseName    = getFormatCaseName(format) + dimensionsString;
1941                                                         const TestParams        testParams              =
1942                                                         {
1943                                                                 false,                                                                                                                          // bool                                                         useSingleMipLevel;
1944                                                                 imageTypesToTest[imageTypeIndex],                                                                       // VkImageType                                          imageType;
1945                                                                 format,                                                                                                                         // VkFormat                                                     imageFormat;
1946                                                                 imageTilingsToTest[imageTilingIndex],                                                           // VkImageTiling                                        imageTiling;
1947                                                                 dimensions,                                                                                                                     // VkExtent3D                                           imageExtent;
1948                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,          // deUint32                                                     imageLayerCount;
1949                                                                 {
1950                                                                         0u,
1951                                                                         imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
1952                                                                 },                                                                                                                                      // LayerRange                                           imageViewLayerRange;
1953                                                                 makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),                            // VkClearValue                                         initValue;
1954                                                                 {
1955                                                                         makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f),                            // VkClearValue                                         clearValue[0];
1956                                                                         makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f),                            // VkClearValue                                         clearValue[1];
1957                                                                 },
1958                                                                 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,          // LayerRange                                           clearLayerRange;
1959                                                                 allocationKind,                                                                                                         // AllocationKind                                       allocationKind;
1960                                                                 false,                                                                                                                          // bool                                                         isCube;
1961                                                                 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE,                                                        // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
1962                                                         };
1963                                                         if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
1964                                                                 imageLayersGroup->addChild(new InstanceFactory1<ClearColorImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Image", testParams));
1965                                                         else
1966                                                                 imageLayersGroup->addChild(new InstanceFactory1<TwoStepClearColorImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Image", testParams));
1967                                                 }
1968                                         }
1969                                         imageTilingGroup->addChild(imageLayersGroup.release());
1970                                 }
1971                                 imageTypeGroup->addChild(imageTilingGroup.release());
1972                         }
1973                         colorImageClearTests->addChild(imageTypeGroup.release());
1974                 }
1975                 imageClearingTests->addChild(colorImageClearTests.release());
1976         }
1977
1978         // Clear depth/stencil image
1979         {
1980                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfImageLayerParamsToTest; ++imageLayerParamsIndex)
1981                 {
1982                         // CUBE images are not tested in clear image tests (they are tested in clear attachment tests)
1983                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube)
1984                                 continue;
1985
1986                         de::MovePtr<TestCaseGroup> imageLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
1987
1988                         for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
1989                         {
1990                                 const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
1991                                 const std::string       dimensionsString        = extentToString(dimensions, VK_IMAGE_TYPE_2D);
1992
1993                                 if (dimensions.height == 1 || dimensions.depth > 1)
1994                                         continue;
1995
1996                                 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
1997                                 {
1998                                         const VkFormat  format                                          = depthStencilImageFormatsToTest[imageFormatIndex];
1999                                         const bool              hasDepth                                        = tcu::hasDepthComponent(mapVkFormat(format).order);
2000                                         const bool              hasStencil                                      = tcu::hasStencilComponent(mapVkFormat(format).order);
2001                                         const int               separateLayoutsLoopCount        = (hasDepth && hasStencil) ? 3 : 1;
2002
2003                                         for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
2004                                         {
2005                                                 const std::string       testCaseName    = getFormatCaseName(format) +
2006                                                         ((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
2007                                                          (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
2008                                                          "")
2009                                                         + dimensionsString;
2010                                                 const TestParams        testParams              =
2011                                                 {
2012                                                         true,                                                                                                                           // bool                                                         useSingleMipLevel;
2013                                                         VK_IMAGE_TYPE_2D,                                                                                                       // VkImageType                                          imageType;
2014                                                         format,                                                                                                                         // VkFormat                                                     format;
2015                                                         VK_IMAGE_TILING_OPTIMAL,                                                                                        // VkImageTiling                                        tiling;
2016                                                         dimensions,                                                                                                                     // VkExtent3D                                           extent;
2017                                                         imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,          // deUint32                                                     imageLayerCount;
2018                                                         {
2019                                                                 0u,
2020                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
2021                                                         },                                                                                                                                      // LayerRange                                           imageViewLayerRange;
2022                                                         makeClearValueDepthStencil(0.5f, 0x03),                                                         // VkClearValue                                         initValue
2023                                                         {
2024                                                                 makeClearValueDepthStencil(0.1f, 0x06),                                                         // VkClearValue                                         clearValue[0];
2025                                                                 makeClearValueDepthStencil(0.3f, 0x04),                                                         // VkClearValue                                         clearValue[1];
2026                                                         },
2027                                                         imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,          // LayerRange                                           clearLayerRange;
2028                                                         allocationKind,                                                                                                         // AllocationKind                                       allocationKind;
2029                                                         false,                                                                                                                          // bool                                                         isCube;
2030                                                         SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode),         // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
2031                                                 };
2032
2033                                                 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2034                                                         imageLayersGroup->addChild(new InstanceFactory1<ClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
2035                                                 else
2036                                                         imageLayersGroup->addChild(new InstanceFactory1<TwoStepClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
2037                                         }
2038                                 }
2039                         }
2040                         depthStencilImageClearTests->addChild(imageLayersGroup.release());
2041                 }
2042                 imageClearingTests->addChild(depthStencilImageClearTests.release());
2043         }
2044
2045         // Clear color attachment
2046         {
2047                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfAttachmentLayerParamsToTest; ++imageLayerParamsIndex)
2048                 {
2049                         if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2050                         {
2051                                 de::MovePtr<TestCaseGroup> colorAttachmentClearLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2052                                 de::MovePtr<TestCaseGroup> partialColorAttachmentClearLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2053
2054                                 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2055                                 {
2056                                         const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
2057                                         const std::string       dimensionsString        = extentToString(dimensions, VK_IMAGE_TYPE_2D);
2058
2059                                         if (dimensions.height == 1 || dimensions.depth > 1)
2060                                                 continue;
2061
2062                                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube && dimensions.width != dimensions.height)
2063                                                 continue;
2064
2065                                         for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
2066                                         {
2067                                                 const VkFormat          format                  = colorImageFormatsToTest[imageFormatIndex];
2068                                                 const std::string       testCaseName    = getFormatCaseName(format) + dimensionsString;
2069                                                 const TestParams        testParams              =
2070                                                 {
2071                                                         true,                                                                                                                   // bool                                                         useSingleMipLevel;
2072                                                         VK_IMAGE_TYPE_2D,                                                                                               // VkImageType                                          imageType;
2073                                                         format,                                                                                                                 // VkFormat                                                     format;
2074                                                         VK_IMAGE_TILING_OPTIMAL,                                                                                // VkImageTiling                                        tiling;
2075                                                         dimensions,                                                                                                             // VkExtent3D                                           extent;
2076                                                         imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,  // deUint32                                                     imageLayerCount;
2077                                                         imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,   // LayerRange                                           imageViewLayerRange;
2078                                                         makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),                    // VkClearValue                                         initValue
2079                                                         {
2080                                                                 makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f),                    // VkClearValue                                         clearValue[0];
2081                                                                 makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f),                    // VkClearValue                                         clearValue[1];
2082                                                         },
2083                                                         imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,  // LayerRange                                           clearLayerRange;
2084                                                         allocationKind,                                                                                                 // AllocationKind                                       allocationKind;
2085                                                         imageLayerParamsToTest[imageLayerParamsIndex].isCube,                   // bool                                                         isCube;
2086                                                         SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE,                                                // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
2087                                                 };
2088                                                 colorAttachmentClearLayersGroup->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Attachment", testParams));
2089                                                 if (dimensions.width > 1)
2090                                                         partialColorAttachmentClearLayersGroup->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Partial Clear Color Attachment", testParams));
2091                                         }
2092                                 }
2093                                 colorAttachmentClearTests->addChild(colorAttachmentClearLayersGroup.release());
2094                                 partialColorAttachmentClearTests->addChild(partialColorAttachmentClearLayersGroup.release());
2095                         }
2096                 }
2097                 imageClearingTests->addChild(colorAttachmentClearTests.release());
2098                 imageClearingTests->addChild(partialColorAttachmentClearTests.release());
2099         }
2100
2101         // Clear depth/stencil attachment
2102         {
2103                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfAttachmentLayerParamsToTest; ++imageLayerParamsIndex)
2104                 {
2105                         if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2106                         {
2107                                 de::MovePtr<TestCaseGroup> depthStencilLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2108                                 de::MovePtr<TestCaseGroup> partialDepthStencilLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2109
2110                                 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2111                                 {
2112                                         const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
2113                                         const std::string       dimensionsString        = extentToString(dimensions, VK_IMAGE_TYPE_2D);
2114
2115                                         if (dimensions.height == 1 || dimensions.depth > 1)
2116                                                 continue;
2117
2118                                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube && dimensions.width != dimensions.height)
2119                                                 continue;
2120
2121                                         for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
2122                                         {
2123                                                 const VkFormat          format                                          = depthStencilImageFormatsToTest[imageFormatIndex];
2124                                                 const bool                      hasDepth                                        = tcu::hasDepthComponent(mapVkFormat(format).order);
2125                                                 const bool                      hasStencil                                      = tcu::hasStencilComponent(mapVkFormat(format).order);
2126                                                 const int                       separateLayoutsLoopCount        = (hasDepth && hasStencil) ? 3 : 1;
2127
2128                                                 for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
2129                                                 {
2130                                                         const std::string       testCaseName    = getFormatCaseName(format) +
2131                                                         ((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
2132                                                          (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
2133                                                          "")
2134                                                         + dimensionsString;
2135
2136                                                         const TestParams        testParams                                              =
2137                                                         {
2138                                                                 true,                                                                                                                   // bool                                                         useSingleMipLevel;
2139                                                                 VK_IMAGE_TYPE_2D,                                                                                               // VkImageType                                          imageType;
2140                                                                 format,                                                                                                                 // VkFormat                                                     format;
2141                                                                 VK_IMAGE_TILING_OPTIMAL,                                                                                // VkImageTiling                                        tiling;
2142                                                                 dimensions,                                                                                                             // VkExtent3D                                           extent;
2143                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,  // deUint32                                                     imageLayerCount;
2144                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,   // LayerRange                                           imageViewLayerRange;
2145                                                                 makeClearValueDepthStencil(0.5f, 0x03),                                                 // VkClearValue                                         initValue
2146                                                                 {
2147                                                                         makeClearValueDepthStencil(0.1f, 0x06),                                                 // VkClearValue                                         clearValue[0];
2148                                                                         makeClearValueDepthStencil(0.3f, 0x04),                                                 // VkClearValue                                         clearValue[1];
2149                                                                 },
2150                                                                 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,  // LayerRange                                           clearLayerRange;
2151                                                                 allocationKind,                                                                                                 // AllocationKind                                       allocationKind;
2152                                                                 imageLayerParamsToTest[imageLayerParamsIndex].isCube,                   // bool                                                         isCube;
2153                                                                 SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode), // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
2154                                                         };
2155                                                         depthStencilLayersGroup->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Attachment", testParams));
2156                                                         if (dimensions.width > 1)
2157                                                                 partialDepthStencilLayersGroup->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Partial Clear Depth/Stencil Attachment", testParams));
2158                                                 }
2159                                         }
2160                                 }
2161                                 depthStencilAttachmentClearTests->addChild(depthStencilLayersGroup.release());
2162                                 partialDepthStencilAttachmentClearTests->addChild(partialDepthStencilLayersGroup.release());
2163                         }
2164                 }
2165                 imageClearingTests->addChild(depthStencilAttachmentClearTests.release());
2166                 imageClearingTests->addChild(partialDepthStencilAttachmentClearTests.release());
2167         }
2168
2169         return imageClearingTests;
2170 }
2171
2172 void createCoreImageClearingTests (tcu::TestCaseGroup* group)
2173 {
2174         createImageClearingTestsCommon(group->getTestContext(), group, ALLOCATION_KIND_SUBALLOCATED);
2175 }
2176
2177 void createDedicatedAllocationImageClearingTests (tcu::TestCaseGroup* group)
2178 {
2179         createImageClearingTestsCommon(group->getTestContext(), group, ALLOCATION_KIND_DEDICATED);
2180 }
2181
2182 } // anonymous
2183
2184 TestCaseGroup* createImageClearingTests (TestContext& testCtx)
2185 {
2186         de::MovePtr<TestCaseGroup>      imageClearingTests      (new TestCaseGroup(testCtx, "image_clearing", "Image Clearing Tests"));
2187
2188         imageClearingTests->addChild(createTestGroup(testCtx, "core",                                   "Core Image Clearing Tests",                                                    createCoreImageClearingTests));
2189         imageClearingTests->addChild(createTestGroup(testCtx, "dedicated_allocation",   "Image Clearing Tests For Dedicated Memory Allocation", createDedicatedAllocationImageClearingTests));
2190
2191         return imageClearingTests.release();
2192 }
2193
2194 } // api
2195 } // vkt