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         bool                                                    useSeparateExpectedClearValue;
 489         VkClearValue                                    expectedClearValue[2];
 490         LayerRange                                              clearLayerRange;
 491         AllocationKind                                  allocationKind;
 492         bool                                                    isCube;
 493         SeparateDepthStencilLayoutMode  separateDepthStencilLayoutMode;
 494         bool                                                    isColorMultipleSubresourceRangeTest;
 495 };
 496
 497 class ImageClearingTestInstance : public vkt::TestInstance
 498 {
 499 public:
 500                                                                                 ImageClearingTestInstance               (Context&                       context,
 501                                                                                                                                                  const TestParams&      testParams);
 502
 503         Move<VkCommandPool>                                     createCommandPool                               (VkCommandPoolCreateFlags commandPoolCreateFlags) const;
 504         Move<VkCommandBuffer>                           allocatePrimaryCommandBuffer    (VkCommandPool commandPool) const;
 505         Move<VkImage>                                           createImage                                             (VkImageType imageType, VkFormat format, VkImageTiling tiling, VkExtent3D extent, deUint32 arrayLayerCount, VkImageUsageFlags usage) const;
 506         Move<VkImageView>                                       createImageView                                 (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask, LayerRange layerRange) const;
 507         Move<VkRenderPass>                                      createRenderPass                                (VkFormat format) const;
 508         Move<VkFramebuffer>                                     createFrameBuffer                               (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight, deUint32 imageLayersCount) const;
 509
 510         void                                                            beginCommandBuffer                              (VkCommandBufferUsageFlags usageFlags) const;
 511         void                                                            endCommandBuffer                                (void) const;
 512         void                                                            submitCommandBuffer                             (void) const;
 513         void                                                            beginRenderPass                                 (VkSubpassContents content, VkClearValue clearValue) const;
 514
 515         void                                                            pipelineImageBarrier                    (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask = 0u) const;
 516         de::MovePtr<TextureLevelPyramid>        readImage                                               (VkImageAspectFlags aspectMask, deUint32 baseLayer) const;
 517         tcu::TestStatus                                         verifyResultImage                               (const std::string& successMessage, const UVec4& clearCoords = UVec4()) const;
 518
 519 protected:
 520         enum ViewType
 521         {
 522                 VIEW_TYPE_SINGLE,
 523                 VIEW_TYPE_ARRAY,
 524                 VIEW_TYPE_CUBE
 525         };
 526         VkImageViewType                                         getCorrespondingImageViewType   (VkImageType imageType, ViewType viewType) const;
 527         VkImageUsageFlags                                       getImageUsageFlags                              (VkFormat format) const;
 528         VkImageAspectFlags                                      getImageAspectFlags                             (VkFormat format) const;
 529         bool                                                            getIsAttachmentFormat                   (VkFormat format, VkImageTiling tiling) const;
 530         bool                                                            getIsStencilFormat                              (VkFormat format) const;
 531         bool                                                            getIsDepthFormat                                (VkFormat format) const;
 532         VkImageFormatProperties                         getImageFormatProperties                (void) const;
 533         VkImageCreateFlags                                      getImageCreateFlags                             (void) const;
 534         ViewType                                                        getViewType                                             (deUint32 imageLayerCount) const;
 535         de::MovePtr<Allocation>                         allocateAndBindImageMemory              (VkImage image) const;
 536
 537         const TestParams&                                       m_params;
 538         const VkDevice                                          m_device;
 539         const InstanceInterface&                        m_vki;
 540         const DeviceInterface&                          m_vkd;
 541         const VkQueue                                           m_queue;
 542         const deUint32                                          m_queueFamilyIndex;
 543         Allocator&                                                      m_allocator;
 544
 545         const bool                                                      m_isAttachmentFormat;
 546         const VkImageUsageFlags                         m_imageUsageFlags;
 547         const VkImageAspectFlags                        m_imageAspectFlags;
 548         const VkImageFormatProperties           m_imageFormatProperties;
 549         const deUint32                                          m_imageMipLevels;
 550         const deUint32                                          m_thresholdMipLevel;
 551
 552         Unique<VkCommandPool>                           m_commandPool;
 553         Unique<VkCommandBuffer>                         m_commandBuffer;
 554
 555         Unique<VkImage>                                         m_image;
 556         de::MovePtr<Allocation>                         m_imageMemory;
 557         Unique<VkImageView>                                     m_imageView;
 558         Move<VkRenderPass>                                      m_renderPass;
 559         Move<VkFramebuffer>                                     m_frameBuffer;
 560 };
 561
 562 ImageClearingTestInstance::ImageClearingTestInstance (Context& context, const TestParams& params)
 563         : TestInstance                          (context)
 564         , m_params                                      (params)
 565         , m_device                                      (context.getDevice())
 566         , m_vki                                         (context.getInstanceInterface())
 567         , m_vkd                                         (context.getDeviceInterface())
 568         , m_queue                                       (context.getUniversalQueue())
 569         , m_queueFamilyIndex            (context.getUniversalQueueFamilyIndex())
 570         , m_allocator                           (context.getDefaultAllocator())
 571         , m_isAttachmentFormat          (getIsAttachmentFormat(params.imageFormat, params.imageTiling))
 572         , m_imageUsageFlags                     (getImageUsageFlags(params.imageFormat))
 573         , m_imageAspectFlags            (getImageAspectFlags(params.imageFormat))
 574         , m_imageFormatProperties       (getImageFormatProperties())
 575         , m_imageMipLevels                      (params.useSingleMipLevel ? 1u : getNumMipLevels(params.imageExtent, m_imageFormatProperties.maxMipLevels))
 576         , m_thresholdMipLevel           (std::max(m_imageMipLevels / 2u, 1u))
 577         , m_commandPool                         (createCommandPool(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT))
 578         , m_commandBuffer                       (allocatePrimaryCommandBuffer(*m_commandPool))
 579
 580         , m_image                                       (createImage(params.imageType,
 581                                                                                          params.imageFormat,
 582                                                                                          params.imageTiling,
 583                                                                                          params.imageExtent,
 584                                                                                          params.imageLayerCount,
 585                                                                                          m_imageUsageFlags))
 586
 587         , m_imageMemory                         (allocateAndBindImageMemory(*m_image))
 588         , m_imageView                           (m_isAttachmentFormat ? createImageView(*m_image,
 589                                                                                                  getCorrespondingImageViewType(params.imageType, getViewType(params.imageLayerCount)),
 590                                                                                                  params.imageFormat,
 591                                                                                                  m_imageAspectFlags,
 592                                                                                                  params.imageViewLayerRange) : vk::Move<VkImageView>())
 593
 594 {
 595         if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
 596                 context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
 597
 598         if (m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
 599                 context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
 600
 601         if (m_isAttachmentFormat)
 602         {
 603                 m_renderPass = createRenderPass(params.imageFormat);
 604                 m_frameBuffer = createFrameBuffer(*m_imageView, *m_renderPass, params.imageExtent.width, params.imageExtent.height, params.imageViewLayerRange.layerCount);
 605         }
 606 }
 607
 608 ImageClearingTestInstance::ViewType ImageClearingTestInstance::getViewType (deUint32 imageLayerCount) const
 609 {
 610         if (imageLayerCount > 1u)
 611                 return m_params.isCube ? VIEW_TYPE_CUBE : VIEW_TYPE_ARRAY;
 612         else
 613                 return VIEW_TYPE_SINGLE;
 614 }
 615
 616 VkImageViewType ImageClearingTestInstance::getCorrespondingImageViewType (VkImageType imageType, ViewType viewType) const
 617 {
 618         switch (imageType)
 619         {
 620         case VK_IMAGE_TYPE_1D:
 621                 return (viewType == VIEW_TYPE_ARRAY) ?  VK_IMAGE_VIEW_TYPE_1D_ARRAY : VK_IMAGE_VIEW_TYPE_1D;
 622         case VK_IMAGE_TYPE_2D:
 623                 if (viewType == VIEW_TYPE_ARRAY)
 624                         return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 625                 else if (viewType == VIEW_TYPE_CUBE)
 626                         return VK_IMAGE_VIEW_TYPE_CUBE;
 627                 else
 628                         return VK_IMAGE_VIEW_TYPE_2D;
 629         case VK_IMAGE_TYPE_3D:
 630                 if (viewType != VIEW_TYPE_SINGLE)
 631                 {
 632                         DE_FATAL("Cannot have 3D image array");
 633                 }
 634                 return VK_IMAGE_VIEW_TYPE_3D;
 635         default:
 636                 DE_FATAL("Unknown image type!");
 637         }
 638
 639         return VK_IMAGE_VIEW_TYPE_2D;
 640 }
 641
 642 VkImageUsageFlags ImageClearingTestInstance::getImageUsageFlags (VkFormat format) const
 643 {
 644         VkImageUsageFlags       commonFlags     = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 645
 646         if (m_isAttachmentFormat)
 647         {
 648                 if (isDepthStencilFormat(format))
 649                         return commonFlags | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 650
 651                 return commonFlags | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 652         }
 653         return commonFlags;
 654 }
 655
 656 VkImageAspectFlags ImageClearingTestInstance::getImageAspectFlags (VkFormat format) const
 657 {
 658         VkImageAspectFlags      imageAspectFlags        = 0;
 659
 660         if (getIsDepthFormat(format))
 661                 imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
 662
 663         if (getIsStencilFormat(format))
 664                 imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
 665
 666         if (imageAspectFlags == 0)
 667                 imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
 668
 669         return imageAspectFlags;
 670 }
 671
 672 bool ImageClearingTestInstance::getIsAttachmentFormat (VkFormat format, VkImageTiling tiling) const
 673 {
 674         const VkFormatProperties props          = vk::getPhysicalDeviceFormatProperties(m_vki, m_context.getPhysicalDevice(), format);
 675         const VkFormatFeatureFlags features     = tiling == VK_IMAGE_TILING_OPTIMAL ? props.optimalTilingFeatures : props.linearTilingFeatures;
 676
 677         return (features & (vk::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) != 0;
 678 }
 679
 680 bool ImageClearingTestInstance::getIsStencilFormat (VkFormat format) const
 681 {
 682         const TextureFormat tcuFormat   = mapVkFormat(format);
 683
 684         if (tcuFormat.order == TextureFormat::S || tcuFormat.order == TextureFormat::DS)
 685                 return true;
 686
 687         return false;
 688 }
 689
 690 bool ImageClearingTestInstance::getIsDepthFormat (VkFormat format) const
 691 {
 692         const TextureFormat     tcuFormat       = mapVkFormat(format);
 693
 694         if (tcuFormat.order == TextureFormat::D || tcuFormat.order == TextureFormat::DS)
 695                 return true;
 696
 697         return false;
 698 }
 699
 700 VkImageCreateFlags ImageClearingTestInstance::getImageCreateFlags (void) const
 701 {
 702         return m_params.isCube ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : (VkImageCreateFlags)0;
 703 }
 704
 705 VkImageFormatProperties ImageClearingTestInstance::getImageFormatProperties (void) const
 706 {
 707         VkImageFormatProperties properties;
 708         const VkResult result = m_vki.getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(), m_params.imageFormat, m_params.imageType,
 709                                                                                                                                                  m_params.imageTiling, m_imageUsageFlags, getImageCreateFlags(), &properties);
 710
 711         if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
 712                 TCU_THROW(NotSupportedError, "Format not supported");
 713         else
 714                 return properties;
 715 }
 716
 717 de::MovePtr<Allocation> ImageClearingTestInstance::allocateAndBindImageMemory (VkImage image) const
 718 {
 719         de::MovePtr<Allocation> imageMemory     (allocateImage(m_vki, m_vkd, m_context.getPhysicalDevice(), m_device, image, MemoryRequirement::Any, m_allocator, m_params.allocationKind));
 720         VK_CHECK(m_vkd.bindImageMemory(m_device, image, imageMemory->getMemory(), imageMemory->getOffset()));
 721         return imageMemory;
 722 }
 723
 724 Move<VkCommandPool> ImageClearingTestInstance::createCommandPool (VkCommandPoolCreateFlags commandPoolCreateFlags) const
 725 {
 726         return vk::createCommandPool(m_vkd, m_device, commandPoolCreateFlags, m_queueFamilyIndex);
 727 }
 728
 729 Move<VkCommandBuffer> ImageClearingTestInstance::allocatePrimaryCommandBuffer (VkCommandPool commandPool) const
 730 {
 731         return vk::allocateCommandBuffer(m_vkd, m_device, commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 732 }
 733
 734 Move<VkImage> ImageClearingTestInstance::createImage (VkImageType imageType, VkFormat format, VkImageTiling tiling, VkExtent3D extent, deUint32 arrayLayerCount, VkImageUsageFlags usage) const
 735 {
 736         if (arrayLayerCount > m_imageFormatProperties.maxArrayLayers)
 737                 TCU_THROW(NotSupportedError, "Device does not support enough image array layers");
 738
 739         const VkImageCreateInfo                                 imageCreateInfo                 =
 740         {
 741                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,            // VkStructureType                      sType;
 742                 DE_NULL,                                                                        // const void*                          pNext;
 743                 getImageCreateFlags(),                                          // VkImageCreateFlags           flags;
 744                 imageType,                                                                      // VkImageType                          imageType;
 745                 format,                                                                         // VkFormat                                     format;
 746                 extent,                                                                         // VkExtent3D                           extent;
 747                 m_imageMipLevels,                                                       // deUint32                                     mipLevels;
 748                 arrayLayerCount,                                                        // deUint32                                     arrayLayers;
 749                 VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits        samples;
 750                 tiling,                                                                         // VkImageTiling                        tiling;
 751                 usage,                                                                          // VkImageUsageFlags            usage;
 752                 VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                        sharingMode;
 753                 1u,                                                                                     // deUint32                                     queueFamilyIndexCount;
 754                 &m_queueFamilyIndex,                                            // const deUint32*                      pQueueFamilyIndices;
 755                 VK_IMAGE_LAYOUT_UNDEFINED                                       // VkImageLayout                        initialLayout;
 756         };
 757
 758         return vk::createImage(m_vkd, m_device, &imageCreateInfo, DE_NULL);
 759 }
 760
 761 Move<VkImageView> ImageClearingTestInstance::createImageView (VkImage image, VkImageViewType viewType, VkFormat format, VkImageAspectFlags aspectMask, LayerRange layerRange) const
 762 {
 763         const VkImageViewCreateInfo                             imageViewCreateInfo             =
 764         {
 765                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                              sType;
 766                 DE_NULL,                                                                        // const void*                                  pNext;
 767                 0u,                                                                                     // VkImageViewCreateFlags               flags;
 768                 image,                                                                          // VkImage                                              image;
 769                 viewType,                                                                       // VkImageViewType                              viewType;
 770                 format,                                                                         // VkFormat                                             format;
 771                 {
 772                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   r;
 773                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   g;
 774                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   b;
 775                         VK_COMPONENT_SWIZZLE_IDENTITY,                          // VkComponentSwizzle                   a;
 776                 },                                                                                      // VkComponentMapping                   components;
 777                 {
 778                         aspectMask,                                                                     // VkImageAspectFlags                   aspectMask;
 779                         0u,                                                                                     // deUint32                                             baseMipLevel;
 780                         1u,                                                                                     // deUint32                                             mipLevels;
 781                         layerRange.baseArrayLayer,                                      // deUint32                                             baseArrayLayer;
 782                         layerRange.layerCount,                                          // deUint32                                             arraySize;
 783                 },                                                                                              // VkImageSubresourceRange              subresourceRange;
 784         };
 785
 786         return vk::createImageView(m_vkd, m_device, &imageViewCreateInfo, DE_NULL);
 787 }
 788
 789 Move<VkRenderPass> ImageClearingTestInstance::createRenderPass (VkFormat format) const
 790 {
 791         if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
 792         {
 793                 VkImageLayout                                                   imageLayout;
 794
 795                 if (isDepthStencilFormat(format))
 796                         imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 797                 else
 798                         imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 799
 800                 const VkAttachmentDescription                   attachmentDesc                  =
 801                 {
 802                         0u,                                                                                                     // VkAttachmentDescriptionFlags         flags;
 803                         format,                                                                                         // VkFormat                                                     format;
 804                         VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 805                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 806                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 807                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           stencilLoadOp;
 808                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          stencilStoreOp;
 809                         imageLayout,                                                                            // VkImageLayout                                        initialLayout;
 810                         imageLayout,                                                                            // VkImageLayout                                        finalLayout;
 811                 };
 812
 813                 const VkAttachmentDescription                   attachments[1]                  =
 814                 {
 815                         attachmentDesc
 816                 };
 817
 818                 const VkAttachmentReference                             attachmentRef                   =
 819                 {
 820                         0u,                                                                                                     // deUint32                                                     attachment;
 821                         imageLayout,                                                                            // VkImageLayout                                        layout;
 822                 };
 823
 824                 const VkAttachmentReference*                    pColorAttachments               = DE_NULL;
 825                 const VkAttachmentReference*                    pDepthStencilAttachment = DE_NULL;
 826                 deUint32                                                                colorAttachmentCount    = 1;
 827
 828                 if (isDepthStencilFormat(format))
 829                 {
 830                         colorAttachmentCount    = 0;
 831                         pDepthStencilAttachment = &attachmentRef;
 832                 }
 833                 else
 834                 {
 835                         colorAttachmentCount    = 1;
 836                         pColorAttachments               = &attachmentRef;
 837                 }
 838
 839                 const VkSubpassDescription                              subpassDesc[1]                  =
 840                 {
 841                         {
 842                                 0u,                                                                                             // VkSubpassDescriptionFlags            flags;
 843                                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                // VkPipelineBindPoint                          pipelineBindPoint;
 844                                 0u,                                                                                             // deUint32                                                     inputAttachmentCount;
 845                                 DE_NULL,                                                                                // const VkAttachmentReference*         pInputAttachments;
 846                                 colorAttachmentCount,                                                   // deUint32                                                     colorAttachmentCount;
 847                                 pColorAttachments,                                                              // const VkAttachmentReference*         pColorAttachments;
 848                                 DE_NULL,                                                                                // const VkAttachmentReference*         pResolveAttachments;
 849                                 pDepthStencilAttachment,                                                // const VkAttachmentReference*         pDepthStencilAttachment;
 850                                 0u,                                                                                             // deUint32                                                     preserveAttachmentCount;
 851                                 DE_NULL,                                                                                // const VkAttachmentReference*         pPreserveAttachments;
 852                         }
 853                 };
 854
 855                 const VkRenderPassCreateInfo                    renderPassCreateInfo    =
 856                 {
 857                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                      // VkStructureType                                      sType;
 858                         DE_NULL,                                                                                        // const void*                                          pNext;
 859                         0u,                                                                                                     // VkRenderPassCreateFlags                      flags;
 860                         1u,                                                                                                     // deUint32                                                     attachmentCount;
 861                         attachments,                                                                            // const VkAttachmentDescription*       pAttachments;
 862                         1u,                                                                                                     // deUint32                                                     subpassCount;
 863                         subpassDesc,                                                                            // const VkSubpassDescription*          pSubpasses;
 864                         0u,                                                                                                     // deUint32                                                     dependencyCount;
 865                         DE_NULL,                                                                                        // const VkSubpassDependency*           pDependencies;
 866                 };
 867
 868                 return vk::createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
 869         }
 870         else
 871         {
 872                 // Make sure VK_KHR_create_renderpass2 is supported. Due to InstanceFactory1 being used and the render pass being created in
 873                 // the instance constructor and not every time, this is the best moment to check.
 874                 m_context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
 875
 876                 VkImageLayout                                                           initialLayout                   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 877                 VkImageLayout                                                           finalLayout                             = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 878                 VkAttachmentDescriptionStencilLayoutKHR         stencilLayouts                  =
 879                 {
 880                         VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
 881                         DE_NULL,
 882                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
 883                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
 884                 };
 885
 886                 VkImageLayout                                                           imageLayout;
 887                 VkAttachmentReferenceStencilLayoutKHR           stencilLayoutRef                =
 888                 {
 889                         VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR,
 890                         DE_NULL,
 891                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
 892                 };
 893
 894                 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
 895                 {
 896                         initialLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
 897                         finalLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
 898                         stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 899                         stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_GENERAL;
 900                         imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
 901                         stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_GENERAL;
 902                 }
 903                 else
 904                 {
 905                         initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 906                         finalLayout = VK_IMAGE_LAYOUT_GENERAL;
 907                         stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
 908                         stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
 909                         imageLayout = VK_IMAGE_LAYOUT_GENERAL;
 910                         stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
 911                 }
 912
 913                 const VkAttachmentDescription2KHR                       attachmentDesc                  =
 914                 {
 915                         VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,         // VkStructureType                                      sType;
 916                         &stencilLayouts,                                                                        // const void*                                          pNext;
 917                         0u,                                                                                                     // VkAttachmentDescriptionFlags         flags;
 918                         format,                                                                                         // VkFormat                                                     format;
 919                         VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 920                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 921                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 922                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           stencilLoadOp;
 923                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          stencilStoreOp;
 924                         initialLayout,                                                                          // VkImageLayout                                        initialLayout;
 925                         finalLayout,                                                                            // VkImageLayout                                        finalLayout;
 926                 };
 927
 928                 const VkAttachmentReference2KHR                         attachmentRef                   =
 929                 {
 930                         VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,           // VkStructureType              sType;
 931                         &stencilLayoutRef,                                                                      // const void*                  pNext;
 932                         0u,                                                                                                     // deUint32                             attachment;
 933                         imageLayout,                                                                            // VkImageLayout                layout;
 934                         0u,                                                                                                     // VkImageAspectFlags   aspectMask;
 935                 };
 936
 937                 const VkSubpassDescription2KHR                          subpassDesc                     =
 938                 {
 939                         VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR,    // VkStructureType                                      sType;
 940                         DE_NULL,                                                                                // const void*                                          pNext;
 941                         0u,                                                                                             // VkSubpassDescriptionFlags            flags;
 942                         VK_PIPELINE_BIND_POINT_GRAPHICS,                                // VkPipelineBindPoint                          pipelineBindPoint;
 943                         0u,                                                                                             // deUint32                                                     viewMask;
 944                         0u,                                                                                             // deUint32                                                     inputAttachmentCount;
 945                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pInputAttachments;
 946                         0u,                                                                                             // deUint32                                                     colorAttachmentCount;
 947                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pColorAttachments;
 948                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pResolveAttachments;
 949                         &attachmentRef,                                                                 // const VkAttachmentReference2KHR*     pDepthStencilAttachment;
 950                         0u,                                                                                             // deUint32                                                     preserveAttachmentCount;
 951                         DE_NULL,                                                                                // const VkAttachmentReference2KHR*     pPreserveAttachments;
 952                 };
 953
 954                 const VkRenderPassCreateInfo2KHR                        renderPassCreateInfo    =
 955                 {
 956                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR,        // VkStructureType                                      sType;
 957                         DE_NULL,                                                                                        // const void*                                          pNext;
 958                         0u,                                                                                                     // VkRenderPassCreateFlags                      flags;
 959                         1u,                                                                                                     // deUint32                                                     attachmentCount;
 960                         &attachmentDesc,                                                                        // const VkAttachmentDescription*       pAttachments;
 961                         1u,                                                                                                     // deUint32                                                     subpassCount;
 962                         &subpassDesc,                                                                           // const VkSubpassDescription*          pSubpasses;
 963                         0u,                                                                                                     // deUint32                                                     dependencyCount;
 964                         DE_NULL,                                                                                        // const VkSubpassDependency*           pDependencies;
 965                         0u,                                                                                                     // deUint32                                                     correlatedViewMaskCount;
 966                         DE_NULL,                                                                                        // const deUint32*                                      pCorrelatedViewMasks;
 967                 };
 968
 969                 return vk::createRenderPass2(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
 970         }
 971 }
 972
 973 Move<VkFramebuffer> ImageClearingTestInstance::createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight, deUint32 imageLayersCount) const
 974 {
 975         const VkImageView                                               attachmentViews[1]              =
 976         {
 977                 imageView
 978         };
 979
 980         const VkFramebufferCreateInfo                   framebufferCreateInfo   =
 981         {
 982                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,      // VkStructureType                      sType;
 983                 DE_NULL,                                                                        // const void*                          pNext;
 984                 0u,                                                                                     // VkFramebufferCreateFlags     flags;
 985                 renderPass,                                                                     // VkRenderPass                         renderPass;
 986                 1,                                                                                      // deUint32                                     attachmentCount;
 987                 attachmentViews,                                                        // const VkImageView*           pAttachments;
 988                 imageWidth,                                                                     // deUint32                                     width;
 989                 imageHeight,                                                            // deUint32                                     height;
 990                 imageLayersCount,                                                       // deUint32                                     layers;
 991         };
 992
 993         return createFramebuffer(m_vkd, m_device, &framebufferCreateInfo, DE_NULL);
 994 }
 995
 996 void ImageClearingTestInstance::beginCommandBuffer (VkCommandBufferUsageFlags usageFlags) const
 997 {
 998         vk::beginCommandBuffer(m_vkd, *m_commandBuffer, usageFlags);
 999 }
1000
1001 void ImageClearingTestInstance::endCommandBuffer (void) const
1002 {
1003         vk::endCommandBuffer(m_vkd, *m_commandBuffer);
1004 }
1005
1006 void ImageClearingTestInstance::submitCommandBuffer (void) const
1007 {
1008         submitCommandsAndWait(m_vkd, m_device, m_queue, m_commandBuffer.get());
1009 }
1010
1011 void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask) const
1012 {
1013         if (!aspectMask || m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
1014                 aspectMask = m_imageAspectFlags;
1015
1016         const VkImageMemoryBarrier              imageBarrier    =
1017         {
1018                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1019                 DE_NULL,                                                                        // const void*                          pNext;
1020                 srcAccessMask,                                                          // VkAccessFlags                        srcAccessMask;
1021                 dstAccessMask,                                                          // VkAccessFlags                        dstAccessMask;
1022                 oldLayout,                                                                      // VkImageLayout                        oldLayout;
1023                 newLayout,                                                                      // VkImageLayout                        newLayout;
1024                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1025                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     destQueueFamilyIndex;
1026                 *m_image,                                                                       // VkImage                                      image;
1027                 {
1028                         aspectMask,                                                                     // VkImageAspectFlags   aspectMask;
1029                         0u,                                                                                     // deUint32                             baseMipLevel;
1030                         VK_REMAINING_MIP_LEVELS,                                        // deUint32                             levelCount;
1031                         0u,                                                                                     // deUint32                             baseArrayLayer;
1032                         VK_REMAINING_ARRAY_LAYERS,                                      // deUint32                             layerCount;
1033                 },                                                                                      // VkImageSubresourceRange      subresourceRange;
1034         };
1035
1036         m_vkd.cmdPipelineBarrier(*m_commandBuffer, srcStageMask, dstStageMask, 0, 0, DE_NULL, 0, DE_NULL, 1, &imageBarrier);
1037 }
1038
1039 de::MovePtr<TextureLevelPyramid> ImageClearingTestInstance::readImage (VkImageAspectFlags aspectMask, deUint32 arrayLayer) const
1040 {
1041         const TextureFormat                                     tcuFormat               = aspectMask == VK_IMAGE_ASPECT_COLOR_BIT ? mapVkFormat(m_params.imageFormat) :
1042                                                                                                                   aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT ? getDepthCopyFormat(m_params.imageFormat) :
1043                                                                                                                   aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT ? getStencilCopyFormat(m_params.imageFormat) :
1044                                                                                                                   TextureFormat();
1045         const deUint32                                          pixelSize               = getPixelSize(tcuFormat);
1046         deUint32                                                        alignment               = 4;    // subsequent mip levels aligned to 4 bytes
1047
1048         if (!getIsDepthFormat(m_params.imageFormat) && !getIsStencilFormat(m_params.imageFormat))
1049                 alignment = lowestCommonMultiple(pixelSize, alignment); // alignment must be multiple of pixel size, if not D/S.
1050
1051         const std::vector<deUint32>                     mipLevelSizes   = getImageMipLevelSizes(pixelSize, m_params.imageExtent, m_imageMipLevels, alignment);
1052         const VkDeviceSize                                      imageTotalSize  = std::accumulate(mipLevelSizes.begin(), mipLevelSizes.end(), 0u);
1053
1054         de::MovePtr<TextureLevelPyramid>        result                  (new TextureLevelPyramid(tcuFormat, m_imageMipLevels));
1055         Move<VkBuffer>                                          buffer;
1056         de::MovePtr<Allocation>                         bufferAlloc;
1057
1058         // Create destination buffer
1059         {
1060                 const VkBufferCreateInfo        bufferParams    =
1061                 {
1062                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
1063                         DE_NULL,                                                                        // const void*                  pNext;
1064                         0u,                                                                                     // VkBufferCreateFlags  flags;
1065                         imageTotalSize,                                                         // VkDeviceSize                 size;
1066                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
1067                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
1068                         0u,                                                                                     // deUint32                             queueFamilyIndexCount;
1069                         DE_NULL                                                                         // const deUint32*              pQueueFamilyIndices;
1070                 };
1071
1072                 buffer          = createBuffer(m_vkd, m_device, &bufferParams);
1073                 bufferAlloc     = allocateBuffer(m_vki, m_vkd, m_context.getPhysicalDevice(), m_device, *buffer, MemoryRequirement::HostVisible, m_allocator, m_params.allocationKind);
1074                 VK_CHECK(m_vkd.bindBufferMemory(m_device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
1075         }
1076
1077         // Barriers for copying image to buffer
1078
1079         const VkBufferMemoryBarrier             bufferBarrier   =
1080         {
1081                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
1082                 DE_NULL,                                                                        // const void*          pNext;
1083                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
1084                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
1085                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
1086                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
1087                 *buffer,                                                                        // VkBuffer                     buffer;
1088                 0u,                                                                                     // VkDeviceSize         offset;
1089                 imageTotalSize,                                                         // VkDeviceSize         size;
1090         };
1091
1092         // Copy image to buffer
1093         std::vector<VkBufferImageCopy> copyRegions;
1094         {
1095                 deUint32 offset = 0u;
1096                 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1097                 {
1098                         const VkExtent3D                extent  = getMipLevelExtent(m_params.imageExtent, mipLevel);
1099                         const VkBufferImageCopy region  =
1100                         {
1101                                 offset,                                                                         // VkDeviceSize                         bufferOffset;
1102                                 0u,                                                                                     // deUint32                                     bufferRowLength;
1103                                 0u,                                                                                     // deUint32                                     bufferImageHeight;
1104                                 { aspectMask, mipLevel, arrayLayer, 1u },       // VkImageSubresourceLayers     imageSubresource;
1105                                 { 0, 0, 0 },                                                            // VkOffset3D                           imageOffset;
1106                                 extent                                                                          // VkExtent3D                           imageExtent;
1107                         };
1108                         copyRegions.push_back(region);
1109                         offset += mipLevelSizes[mipLevel];
1110                 }
1111         }
1112
1113         beginCommandBuffer(0);
1114
1115         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
1116                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,
1117                                                  VK_ACCESS_TRANSFER_WRITE_BIT,
1118                                                  VK_ACCESS_TRANSFER_READ_BIT,
1119                                                  VK_IMAGE_LAYOUT_GENERAL,
1120                                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1121                                                  aspectMask);
1122
1123         m_vkd.cmdCopyImageToBuffer(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, static_cast<deUint32>(copyRegions.size()), &copyRegions[0]);
1124         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);
1125
1126         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
1127                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,
1128                                                  VK_ACCESS_TRANSFER_READ_BIT,
1129                                                  VK_ACCESS_TRANSFER_READ_BIT,
1130                                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1131                                                  VK_IMAGE_LAYOUT_GENERAL,
1132                                                  aspectMask);
1133
1134         endCommandBuffer();
1135         submitCommandBuffer();
1136
1137         invalidateAlloc(m_vkd, m_device, *bufferAlloc);
1138
1139         {
1140                 deUint32 offset = 0u;
1141                 for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1142                 {
1143                         const VkExtent3D        extent          = getMipLevelExtent(m_params.imageExtent, mipLevel);
1144                         const void*                     pLevelData      = static_cast<const void*>(reinterpret_cast<deUint8*>(bufferAlloc->getHostPtr()) + offset);
1145
1146                         result->allocLevel(mipLevel, extent.width, extent.height, extent.depth);
1147                         copy(result->getLevel(mipLevel), ConstPixelBufferAccess(result->getFormat(), result->getLevel(mipLevel).getSize(), pLevelData));
1148
1149                         offset += mipLevelSizes[mipLevel];
1150                 }
1151         }
1152
1153         return result;
1154 }
1155
1156 tcu::TestStatus ImageClearingTestInstance::verifyResultImage (const std::string& successMessage, const UVec4& clearCoords) const
1157 {
1158         DE_ASSERT((clearCoords == UVec4()) || m_params.imageExtent.depth == 1u);
1159
1160         if (getIsDepthFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1161         {
1162                 DE_ASSERT(m_imageMipLevels == 1u);
1163
1164                 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount; ++arrayLayer)
1165                 {
1166                         de::MovePtr<TextureLevelPyramid>        image                   = readImage(VK_IMAGE_ASPECT_DEPTH_BIT, arrayLayer);
1167                         std::string                                                     message;
1168                         float                                                           depthValue;
1169
1170                         for (deUint32 y = 0; y < m_params.imageExtent.height; ++y)
1171                         for (deUint32 x = 0; x < m_params.imageExtent.width; ++x)
1172                         {
1173                                 if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1174                                         depthValue = m_params.clearValue[0].depthStencil.depth;
1175                                 else
1176                                 if (isInInitialClearRange(m_isAttachmentFormat, 0u /* mipLevel */, arrayLayer, m_params.imageViewLayerRange))
1177                                 {
1178                                         depthValue = m_params.initValue.depthStencil.depth;
1179                                 }
1180                                 else
1181                                         continue;
1182
1183                                 if (!comparePixelToDepthClearValue(image->getLevel(0), x, y, depthValue, message))
1184                                         return TestStatus::fail("Depth value mismatch! " + message);
1185                         }
1186                 }
1187         }
1188
1189         if (getIsStencilFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1190         {
1191                 DE_ASSERT(m_imageMipLevels == 1u);
1192
1193                 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount; ++arrayLayer)
1194                 {
1195                         de::MovePtr<TextureLevelPyramid>        image                   = readImage(VK_IMAGE_ASPECT_STENCIL_BIT, arrayLayer);
1196                         std::string                                                     message;
1197                         deUint32                                                        stencilValue;
1198
1199                         for (deUint32 y = 0; y < m_params.imageExtent.height; ++y)
1200                         for (deUint32 x = 0; x < m_params.imageExtent.width; ++x)
1201                         {
1202                                 if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1203                                         stencilValue = m_params.clearValue[0].depthStencil.stencil;
1204                                 else
1205                                 if (isInInitialClearRange(m_isAttachmentFormat, 0u /* mipLevel */, arrayLayer, m_params.imageViewLayerRange))
1206                                 {
1207                                         stencilValue = m_params.initValue.depthStencil.stencil;
1208                                 }
1209                                 else
1210                                         continue;
1211
1212                                 if (!comparePixelToStencilClearValue(image->getLevel(0), x, y, stencilValue, message))
1213                                         return TestStatus::fail("Stencil value mismatch! " + message);
1214                         }
1215                 }
1216         }
1217
1218         if (!isDepthStencilFormat(m_params.imageFormat))
1219         {
1220                 for (deUint32 arrayLayer = 0; arrayLayer < m_params.imageLayerCount; ++arrayLayer)
1221                 {
1222                         de::MovePtr<TextureLevelPyramid>        image                   = readImage(VK_IMAGE_ASPECT_COLOR_BIT, arrayLayer);
1223                         std::string                                                     message;
1224                         const VkClearColorValue*                        pColorValue;
1225
1226                         for (deUint32 mipLevel = 0; mipLevel < m_imageMipLevels; ++mipLevel)
1227                         {
1228                                 const int                                       clearColorNdx   = ((mipLevel < m_thresholdMipLevel || m_params.isColorMultipleSubresourceRangeTest) ? 0 : 1);
1229                                 const VkExtent3D                        extent                  = getMipLevelExtent(m_params.imageExtent, mipLevel);
1230                                 const VkClearColorValue*        pExpectedColorValue = &(m_params.useSeparateExpectedClearValue ? m_params.expectedClearValue : m_params.clearValue)[clearColorNdx].color;
1231
1232                                 for (deUint32 z = 0; z < extent.depth;  ++z)
1233                                 for (deUint32 y = 0; y < extent.height; ++y)
1234                                 for (deUint32 x = 0; x < extent.width;  ++x)
1235                                 {
1236                                         if (isInClearRange(clearCoords, x, y, arrayLayer, m_params.imageViewLayerRange, m_params.clearLayerRange))
1237                                         {
1238                                                 pColorValue = pExpectedColorValue;
1239                                         }
1240                                         else
1241                                         {
1242                                                 if (isInInitialClearRange(m_isAttachmentFormat, mipLevel, arrayLayer, m_params.imageViewLayerRange))
1243                                                 {
1244                                                         pColorValue = &m_params.initValue.color;
1245                                                 }
1246                                                 else
1247                                                 {
1248                                                         continue;
1249                                                 }
1250                                         }
1251                                         if (!comparePixelToColorClearValue(image->getLevel(mipLevel), x, y, z, *pColorValue, message))
1252                                                 return TestStatus::fail("Color value mismatch! " + message);
1253                                 }
1254                         }
1255                 }
1256         }
1257
1258         return TestStatus::pass(successMessage);
1259 }
1260
1261 void ImageClearingTestInstance::beginRenderPass (VkSubpassContents content, VkClearValue clearValue) const
1262 {
1263         vk::beginRenderPass(m_vkd, *m_commandBuffer, *m_renderPass, *m_frameBuffer, makeRect2D(0, 0, m_params.imageExtent.width, m_params.imageExtent.height), clearValue, content);
1264 }
1265
1266 class ClearColorImageTestInstance : public ImageClearingTestInstance
1267 {
1268 public:
1269                                                 ClearColorImageTestInstance     (Context& context, const TestParams& testParams, bool twoStep = false) : ImageClearingTestInstance (context, testParams), m_twoStep(twoStep) {}
1270         virtual TestStatus      iterate                                         (void);
1271 protected:
1272         bool                            m_twoStep;
1273 };
1274
1275 class TwoStepClearColorImageTestInstance : public ClearColorImageTestInstance
1276 {
1277 public:
1278         TwoStepClearColorImageTestInstance (Context& context, const TestParams& testParams) : ClearColorImageTestInstance(context, testParams, true) {}
1279 };
1280
1281 class ClearColorImageMultipleSubresourceRangeTestInstance : public ClearColorImageTestInstance
1282 {
1283 public:
1284         ClearColorImageMultipleSubresourceRangeTestInstance     (Context& context, const TestParams& testParams) : ClearColorImageTestInstance(context, testParams, false) {}
1285         virtual TestStatus      iterate                 (void);
1286 };
1287
1288 TestStatus ClearColorImageMultipleSubresourceRangeTestInstance::iterate(void)
1289 {
1290         std::vector<VkImageSubresourceRange> subresourceRanges;
1291
1292         DE_ASSERT(m_imageMipLevels > 1u);
1293
1294         deUint32 mipLevel = 0u;
1295         // Create a subresource range per mipmap level.
1296         do {
1297                 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, mipLevel++, 1u, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1298         } while (mipLevel < m_imageMipLevels);
1299
1300         beginCommandBuffer(0);
1301
1302         pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                         // VkPipelineStageFlags         srcStageMask
1303                                                  VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                    // VkPipelineStageFlags         dstStageMask
1304                                                  0,                                                                                             // VkAccessFlags                        srcAccessMask
1305                                                  (m_isAttachmentFormat
1306                                                         ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
1307                                                         : VK_ACCESS_TRANSFER_WRITE_BIT),                        // VkAccessFlags                        dstAccessMask
1308                                                  VK_IMAGE_LAYOUT_UNDEFINED,                                             // VkImageLayout                        oldLayout;
1309                                                  (m_isAttachmentFormat
1310                                                         ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
1311                                                         : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL));       // VkImageLayout                        newLayout;
1312
1313         if (m_isAttachmentFormat)
1314         {
1315                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1316                 endRenderPass(m_vkd, *m_commandBuffer);
1317
1318                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                // VkPipelineStageFlags         srcStageMask
1319                         VK_PIPELINE_STAGE_TRANSFER_BIT,                                                         // VkPipelineStageFlags         dstStageMask
1320                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                                           // VkAccessFlags                        srcAccessMask
1321                         VK_ACCESS_TRANSFER_WRITE_BIT,                                                           // VkAccessFlags                        dstAccessMask
1322                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                                       // VkImageLayout                        oldLayout;
1323                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);                                          // VkImageLayout                        newLayout;
1324         }
1325
1326         // Test clear color in all ranges
1327         m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].color, static_cast<deUint32>(subresourceRanges.size()), subresourceRanges.data());
1328
1329         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                            // VkPipelineStageFlags         srcStageMask
1330                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,                                // VkPipelineStageFlags         dstStageMask
1331                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                  // VkAccessFlags                        srcAccessMask
1332                                                  VK_ACCESS_TRANSFER_READ_BIT,                                   // VkAccessFlags                        dstAccessMask
1333                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                  // VkImageLayout                        oldLayout;
1334                                                  VK_IMAGE_LAYOUT_GENERAL);                                              // VkImageLayout                        newLayout;
1335
1336         endCommandBuffer();
1337         submitCommandBuffer();
1338
1339         return verifyResultImage("cmdClearColorImage passed");
1340 }
1341
1342 TestStatus ClearColorImageTestInstance::iterate (void)
1343 {
1344         std::vector<VkImageSubresourceRange> subresourceRanges;
1345         std::vector<VkImageSubresourceRange> steptwoRanges;
1346
1347         if (m_imageMipLevels == 1)
1348         {
1349                 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u,                                   1u,                                                     m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount));
1350                 steptwoRanges.push_back(        makeImageSubresourceRange(m_imageAspectFlags, 0u,                                       VK_REMAINING_MIP_LEVELS,        m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1351         }
1352         else
1353         {
1354                 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, 0u,                                   m_thresholdMipLevel,            m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1355                 subresourceRanges.push_back(makeImageSubresourceRange(m_imageAspectFlags, m_thresholdMipLevel,  VK_REMAINING_MIP_LEVELS,        m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1356                 steptwoRanges.push_back(        makeImageSubresourceRange(m_imageAspectFlags, 0u,                                       m_thresholdMipLevel,            m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1357                 steptwoRanges.push_back(        makeImageSubresourceRange(m_imageAspectFlags, m_thresholdMipLevel,      VK_REMAINING_MIP_LEVELS,        m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS));
1358         }
1359
1360         beginCommandBuffer(0);
1361
1362         pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                         // VkPipelineStageFlags         srcStageMask
1363                                                  VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                    // VkPipelineStageFlags         dstStageMask
1364                                                  0,                                                                                             // VkAccessFlags                        srcAccessMask
1365                                                  (m_isAttachmentFormat
1366                                                         ? VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
1367                                                         : VK_ACCESS_TRANSFER_WRITE_BIT),                        // VkAccessFlags                        dstAccessMask
1368                                                  VK_IMAGE_LAYOUT_UNDEFINED,                                             // VkImageLayout                        oldLayout;
1369                                                  (m_isAttachmentFormat
1370                                                         ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
1371                                                         : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL));       // VkImageLayout                        newLayout;
1372
1373         if (m_isAttachmentFormat)
1374         {
1375                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1376                 endRenderPass(m_vkd, *m_commandBuffer);
1377
1378                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                // VkPipelineStageFlags         srcStageMask
1379                         VK_PIPELINE_STAGE_TRANSFER_BIT,                                                         // VkPipelineStageFlags         dstStageMask
1380                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                                           // VkAccessFlags                        srcAccessMask
1381                         VK_ACCESS_TRANSFER_WRITE_BIT,                                                           // VkAccessFlags                        dstAccessMask
1382                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                                       // VkImageLayout                        oldLayout;
1383                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);                                          // VkImageLayout                        newLayout;
1384         }
1385
1386         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                            // VkPipelineStageFlags         srcStageMask
1387                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,                                // VkPipelineStageFlags         dstStageMask
1388                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                  // VkAccessFlags                        srcAccessMask
1389                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                  // VkAccessFlags                        dstAccessMask
1390                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                  // VkImageLayout                        oldLayout;
1391                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);                 // VkImageLayout                        newLayout;
1392
1393         // Different clear color per range
1394         for (std::size_t i = 0u; i < subresourceRanges.size(); ++i)
1395         {
1396                 m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[i].color, 1, &subresourceRanges[i]);
1397
1398                 if (m_twoStep)
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_WRITE_BIT,                                  // VkAccessFlags                        dstAccessMask
1404                                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                  // VkImageLayout                        oldLayout;
1405                                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);                 // VkImageLayout                        newLayout;
1406
1407                         m_vkd.cmdClearColorImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[i].color, 1, &steptwoRanges[i]);
1408                 }
1409         }
1410
1411         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                            // VkPipelineStageFlags         srcStageMask
1412                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,                                // VkPipelineStageFlags         dstStageMask
1413                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                  // VkAccessFlags                        srcAccessMask
1414                                                  VK_ACCESS_TRANSFER_READ_BIT,                                   // VkAccessFlags                        dstAccessMask
1415                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                  // VkImageLayout                        oldLayout;
1416                                                  VK_IMAGE_LAYOUT_GENERAL);                                              // VkImageLayout                        newLayout;
1417
1418         endCommandBuffer();
1419         submitCommandBuffer();
1420
1421         return verifyResultImage("cmdClearColorImage passed");
1422 }
1423
1424 class ClearDepthStencilImageTestInstance : public ImageClearingTestInstance
1425 {
1426 public:
1427                                                 ClearDepthStencilImageTestInstance      (Context& context, const TestParams& testParams, bool twoStep = false) : ImageClearingTestInstance (context, testParams), m_twoStep(twoStep) {}
1428         virtual TestStatus      iterate                                                         (void);
1429 protected:
1430         bool                            m_twoStep;
1431 };
1432
1433 class TwoStepClearDepthStencilImageTestInstance : public ClearDepthStencilImageTestInstance
1434 {
1435 public:
1436         TwoStepClearDepthStencilImageTestInstance (Context& context, const TestParams& testParams) : ClearDepthStencilImageTestInstance (context, testParams, true) { }
1437 };
1438
1439 class ClearDepthStencilImageMultipleSubresourceRangeTestInstance : public ClearDepthStencilImageTestInstance
1440 {
1441 public:
1442         ClearDepthStencilImageMultipleSubresourceRangeTestInstance      (Context& context, const TestParams& testParams) :  ClearDepthStencilImageTestInstance(context, testParams, false) { }
1443         virtual TestStatus      iterate                                 (void);
1444 };
1445
1446 TestStatus ClearDepthStencilImageMultipleSubresourceRangeTestInstance::iterate (void)
1447 {
1448         VkImageLayout           layout  = (m_isAttachmentFormat
1449                                                                         ?       VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
1450                                                                         :       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
1451         VkImageAspectFlags      aspectMask      = m_imageAspectFlags;
1452
1453         // Depth/Stencil formats only. No separate layout modes.
1454         DE_ASSERT(m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE);
1455
1456         std::vector<VkImageSubresourceRange> subresourceRanges;
1457
1458     subresourceRanges.push_back(makeImageSubresourceRange(VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 1u, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1459     subresourceRanges.push_back(makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, m_params.clearLayerRange.baseArrayLayer, m_params.clearLayerRange.layerCount));
1460
1461         beginCommandBuffer(0);
1462
1463         pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                                 // VkPipelineStageFlags         srcStageMask
1464                                                  VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                            // VkPipelineStageFlags         dstStageMask
1465                                                  0,                                                                                                     // VkAccessFlags                        srcAccessMask
1466                                                  (m_isAttachmentFormat
1467                                                         ?       VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
1468                                                         :       VK_ACCESS_TRANSFER_WRITE_BIT),                          // VkAccessFlags                        dstAccessMask
1469                                                  VK_IMAGE_LAYOUT_UNDEFINED,                                                     // VkImageLayout                        oldLayout;
1470                                                  layout,                                                                                        // VkImageLayout                        newLayout;
1471                                                  aspectMask);                                                                           // VkImageAspectFlags           aspectMask;
1472
1473         if (m_isAttachmentFormat)
1474         {
1475                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1476                 endRenderPass(m_vkd, *m_commandBuffer);
1477
1478                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                                        // VkPipelineStageFlags         srcStageMask
1479                                                          VK_PIPELINE_STAGE_TRANSFER_BIT,                                                // VkPipelineStageFlags         dstStageMask
1480                                                          VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,                  // VkAccessFlags                        srcAccessMask
1481                                                          VK_ACCESS_TRANSFER_WRITE_BIT,                                                  // VkAccessFlags                        dstAccessMask
1482                                                          layout,                                                                                                // VkImageLayout                        oldLayout;
1483                                                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                                  // VkImageLayout                        newLayout;
1484                                                          aspectMask);                                                                                   // VkImageAspectFlags           aspectMask;
1485         }
1486
1487         m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, static_cast<deUint32>(subresourceRanges.size()), subresourceRanges.data());
1488
1489         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                                    // VkPipelineStageFlags         srcStageMask
1490                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,                                        // VkPipelineStageFlags         dstStageMask
1491                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                          // VkAccessFlags                        srcAccessMask
1492                                                  VK_ACCESS_TRANSFER_READ_BIT,                                           // VkAccessFlags                        dstAccessMask
1493                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                          // VkImageLayout                        oldLayout;
1494                                                  VK_IMAGE_LAYOUT_GENERAL,                                                       // VkImageLayout                        newLayout;
1495                                                  aspectMask);                                                                           // VkImageAspectFlags           aspectMask;
1496
1497         endCommandBuffer();
1498         submitCommandBuffer();
1499
1500         return verifyResultImage("cmdClearDepthStencilImage passed");
1501 }
1502
1503 TestStatus ClearDepthStencilImageTestInstance::iterate (void)
1504 {
1505         VkImageLayout           layout  = (m_isAttachmentFormat
1506                                                                         ?       VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
1507                                                                         :       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
1508         VkImageAspectFlags      aspectMask      = m_imageAspectFlags;
1509         if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1510         {
1511                 layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
1512                 aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1513         }
1514         else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1515         {
1516                 layout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
1517                 aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1518         }
1519
1520         const VkImageSubresourceRange subresourceRange  = makeImageSubresourceRange(aspectMask, 0u, 1u,                                                 m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount);
1521         const VkImageSubresourceRange steptwoRange              = makeImageSubresourceRange(aspectMask, 0u, VK_REMAINING_MIP_LEVELS,    m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS);
1522
1523         beginCommandBuffer(0);
1524
1525         pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                                 // VkPipelineStageFlags         srcStageMask
1526                                                  VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                            // VkPipelineStageFlags         dstStageMask
1527                                                  0,                                                                                                     // VkAccessFlags                        srcAccessMask
1528                                                  (m_isAttachmentFormat
1529                                                         ?       VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
1530                                                         :       VK_ACCESS_TRANSFER_WRITE_BIT),                          // VkAccessFlags                        dstAccessMask
1531                                                  VK_IMAGE_LAYOUT_UNDEFINED,                                                     // VkImageLayout                        oldLayout;
1532                                                  layout,                                                                                        // VkImageLayout                        newLayout;
1533                                                  aspectMask);                                                                           // VkImageAspectFlags           aspectMask;
1534
1535         if (m_isAttachmentFormat)
1536         {
1537                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1538                 endRenderPass(m_vkd, *m_commandBuffer);
1539
1540                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                                        // VkPipelineStageFlags         srcStageMask
1541                                                          VK_PIPELINE_STAGE_TRANSFER_BIT,                                                // VkPipelineStageFlags         dstStageMask
1542                                                          VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,                  // VkAccessFlags                        srcAccessMask
1543                                                          VK_ACCESS_TRANSFER_WRITE_BIT,                                                  // VkAccessFlags                        dstAccessMask
1544                                                          layout,                                                                                                // VkImageLayout                        oldLayout;
1545                                                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                                  // VkImageLayout                        newLayout;
1546                                                          aspectMask);                                                                                   // VkImageAspectFlags           aspectMask;
1547         }
1548
1549         m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &subresourceRange);
1550
1551         if (m_twoStep) {
1552                 pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                            // VkPipelineStageFlags         srcStageMask
1553                                                          VK_PIPELINE_STAGE_TRANSFER_BIT,                                // VkPipelineStageFlags         dstStageMask
1554                                                          VK_ACCESS_TRANSFER_WRITE_BIT,                                  // VkAccessFlags                        srcAccessMask
1555                                                          VK_ACCESS_TRANSFER_WRITE_BIT,                                  // VkAccessFlags                        dstAccessMask
1556                                                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                  // VkImageLayout                        oldLayout;
1557                                                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);                 // VkImageLayout                        newLayout;
1558
1559                 m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &steptwoRange);
1560     }
1561
1562         pipelineImageBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,                                    // VkPipelineStageFlags         srcStageMask
1563                                                  VK_PIPELINE_STAGE_TRANSFER_BIT,                                        // VkPipelineStageFlags         dstStageMask
1564                                                  VK_ACCESS_TRANSFER_WRITE_BIT,                                          // VkAccessFlags                        srcAccessMask
1565                                                  VK_ACCESS_TRANSFER_READ_BIT,                                           // VkAccessFlags                        dstAccessMask
1566                                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                          // VkImageLayout                        oldLayout;
1567                                                  VK_IMAGE_LAYOUT_GENERAL,                                                       // VkImageLayout                        newLayout;
1568                                                  aspectMask);                                                                           // VkImageAspectFlags           aspectMask;
1569
1570         endCommandBuffer();
1571         submitCommandBuffer();
1572
1573         return verifyResultImage("cmdClearDepthStencilImage passed");
1574 }
1575
1576 class ClearAttachmentTestInstance : public ImageClearingTestInstance
1577 {
1578 public:
1579         enum ClearType
1580         {
1581                 FULL_CLEAR,
1582                 PARTIAL_CLEAR,
1583         };
1584
1585         ClearAttachmentTestInstance (Context& context, const TestParams& testParams, const ClearType clearType = FULL_CLEAR)
1586                 : ImageClearingTestInstance     (context, testParams)
1587                 , m_clearType                           (clearType)
1588         {
1589                 if (!m_isAttachmentFormat)
1590                         TCU_THROW(NotSupportedError, "Format not renderable");
1591         }
1592
1593         TestStatus iterate (void)
1594         {
1595                 const bool                      isDepthStencil          = isDepthStencilFormat(m_params.imageFormat);
1596                 const VkAccessFlags     accessMask                      = (isDepthStencil ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT     : VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
1597                 VkImageLayout           attachmentLayout        = (isDepthStencil ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
1598                 VkImageAspectFlags      aspectMask                      = m_imageAspectFlags;
1599
1600                 if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
1601                 {
1602                         attachmentLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
1603                         aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1604                 }
1605                 else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
1606                 {
1607                         attachmentLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
1608                         aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1609                 }
1610
1611                 const VkClearAttachment clearAttachment =
1612                 {
1613                         aspectMask,                                                     // VkImageAspectFlags   aspectMask;
1614                         0u,                                                                     // deUint32                             colorAttachment;
1615                         m_params.clearValue[0]                          // VkClearValue                 clearValue;
1616                 };
1617
1618                 UVec4                                           clearCoords;
1619                 std::vector<VkClearRect>        clearRects;
1620
1621                 if (m_clearType == FULL_CLEAR)
1622                 {
1623                         const VkClearRect rect =
1624                         {
1625                                 {
1626                                         { 0, 0 },                                                                                                                                       // VkOffset2D    offset;
1627                                         { m_params.imageExtent.width, m_params.imageExtent.height }                                     // VkExtent2D    extent;
1628                                 },                                                                                                                                                      // VkRect2D     rect;
1629                                 m_params.clearLayerRange.baseArrayLayer,                                                                // deUint32     baseArrayLayer;
1630                                 m_params.clearLayerRange.layerCount,                                                                    // deUint32     layerCount;
1631                         };
1632
1633                         clearRects.push_back(rect);
1634                 }
1635                 else
1636                 {
1637                         const deUint32  clearX          = m_params.imageExtent.width  / 8u;
1638                         const deUint32  clearY          = m_params.imageExtent.height / 8u;
1639                         const deUint32  clearWidth      = m_params.imageExtent.width  / 2u;
1640                         const deUint32  clearHeight     = m_params.imageExtent.height / 2u;
1641
1642                         clearCoords     = UVec4(clearX,                                 clearY,
1643                                                                 clearX + clearWidth,    clearY + clearHeight);
1644
1645                         const VkClearRect rects[2] =
1646                         {
1647                                 {
1648                                         {
1649                                                 { 0,                                                    static_cast<deInt32>(clearY)    },              // VkOffset2D    offset;
1650                                                 { m_params.imageExtent.width,   clearHeight                                             }               // VkExtent2D    extent;
1651                                         },                                                                                                                                              // VkRect2D     rect;
1652                                         m_params.clearLayerRange.baseArrayLayer,                                                                // deUint32     baseArrayLayer;
1653                                         m_params.clearLayerRange.layerCount                                                                             // deUint32     layerCount;
1654                                 },
1655                                 {
1656                                         {
1657                                                 { static_cast<deInt32>(clearX), 0                                                       },                      // VkOffset2D    offset;
1658                                                 { clearWidth,                                   m_params.imageExtent.height     }                       // VkExtent2D    extent;
1659                                         },                                                                                                                                              // VkRect2D     rect;
1660                                         m_params.clearLayerRange.baseArrayLayer,                                                                // deUint32     baseArrayLayer;
1661                                         m_params.clearLayerRange.layerCount                                                                             // deUint32     layerCount;
1662                                 }
1663                         };
1664
1665                         clearRects.push_back(rects[0]);
1666                         clearRects.push_back(rects[1]);
1667                 }
1668
1669                 beginCommandBuffer(0);
1670
1671                 pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                         // VkPipelineStageFlags         srcStageMask
1672                                                          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                    // VkPipelineStageFlags         dstStageMask
1673                                                          0,                                                                                             // VkAccessFlags                        srcAccessMask
1674                                                          accessMask,                                                                    // VkAccessFlags                        dstAccessMask
1675                                                          VK_IMAGE_LAYOUT_UNDEFINED,                                             // VkImageLayout                        oldLayout;
1676                                                          attachmentLayout,                                                              // VkImageLayout                        newLayout;
1677                                                          aspectMask);                                                                   // VkImageAspectFlags           aspectMask;
1678
1679                 beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
1680                 m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, static_cast<deUint32>(clearRects.size()), &clearRects[0]);
1681                 endRenderPass(m_vkd, *m_commandBuffer);
1682
1683                 pipelineImageBarrier(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                        // VkPipelineStageFlags         srcStageMask
1684                                                          VK_PIPELINE_STAGE_TRANSFER_BIT,                                // VkPipelineStageFlags         dstStageMask
1685                                                          accessMask,                                                                    // VkAccessFlags                        srcAccessMask
1686                                                          VK_ACCESS_TRANSFER_READ_BIT,                                   // VkAccessFlags                        dstAccessMask
1687                                                          attachmentLayout,                                                              // VkImageLayout                        oldLayout;
1688                                                          VK_IMAGE_LAYOUT_GENERAL,                                               // VkImageLayout                        newLayout;
1689                                                          aspectMask);                                                                   // VkImageAspectFlags           aspectMask;
1690
1691                 endCommandBuffer();
1692                 submitCommandBuffer();
1693
1694                 return verifyResultImage("cmdClearAttachments passed", clearCoords);
1695         }
1696
1697 private:
1698         const ClearType m_clearType;
1699 };
1700
1701 class PartialClearAttachmentTestInstance : public ClearAttachmentTestInstance
1702 {
1703 public:
1704         PartialClearAttachmentTestInstance (Context& context, const TestParams& testParams) : ClearAttachmentTestInstance (context, testParams, PARTIAL_CLEAR) {}
1705 };
1706
1707 VkClearValue makeClearColorValue (VkFormat format, float r, float g, float b, float a)
1708 {
1709         const   TextureFormat tcuFormat = mapVkFormat(format);
1710         VkClearValue clearValue;
1711
1712         if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_FLOATING_POINT
1713                 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
1714                 || getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT)
1715         {
1716                 clearValue.color.float32[0] = r;
1717                 clearValue.color.float32[1] = g;
1718                 clearValue.color.float32[2] = b;
1719                 clearValue.color.float32[3] = a;
1720         }
1721         else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
1722         {
1723                 UVec4 maxValues = getFormatMaxUintValue(tcuFormat);
1724
1725                 clearValue.color.uint32[0] = (deUint32)((float)maxValues[0] * r);
1726                 clearValue.color.uint32[1] = (deUint32)((float)maxValues[1] * g);
1727                 clearValue.color.uint32[2] = (deUint32)((float)maxValues[2] * b);
1728                 clearValue.color.uint32[3] = (deUint32)((float)maxValues[3] * a);
1729         }
1730         else if (getTextureChannelClass(tcuFormat.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER)
1731         {
1732                 IVec4 maxValues = getFormatMaxIntValue(tcuFormat);
1733
1734                 clearValue.color.int32[0] = (deUint32)((float)maxValues[0] * r);
1735                 clearValue.color.int32[1] = (deUint32)((float)maxValues[1] * g);
1736                 clearValue.color.int32[2] = (deUint32)((float)maxValues[2] * b);
1737                 clearValue.color.int32[3] = (deUint32)((float)maxValues[3] * a);
1738         }
1739         else
1740                 DE_FATAL("Unknown channel class");
1741
1742         return clearValue;
1743 }
1744
1745 std::string getFormatCaseName (VkFormat format)
1746 {
1747         return de::toLower(de::toString(getFormatStr(format)).substr(10));
1748 }
1749
1750 const char* getImageTypeCaseName (VkImageType type)
1751 {
1752         const char* s_names[] =
1753         {
1754                 "1d",
1755                 "2d",
1756                 "3d"
1757         };
1758         return de::getSizedArrayElement<VK_CORE_IMAGE_TYPE_LAST>(s_names, type);
1759 }
1760
1761 const char* getImageTilingCaseName (VkImageTiling tiling)
1762 {
1763         const char* s_names[] =
1764         {
1765                 "optimal",
1766                 "linear",
1767         };
1768         return de::getSizedArrayElement<VK_CORE_IMAGE_TILING_LAST>(s_names, tiling);
1769 }
1770
1771 TestCaseGroup* createImageClearingTestsCommon (TestContext& testCtx, tcu::TestCaseGroup* imageClearingTests, AllocationKind allocationKind)
1772 {
1773         de::MovePtr<TestCaseGroup>      colorImageClearTests                                    (new TestCaseGroup(testCtx, "clear_color_image", "Color Image Clear Tests"));
1774         de::MovePtr<TestCaseGroup>      depthStencilImageClearTests                             (new TestCaseGroup(testCtx, "clear_depth_stencil_image", "Color Depth/Stencil Image Tests"));
1775         de::MovePtr<TestCaseGroup>      colorAttachmentClearTests                               (new TestCaseGroup(testCtx, "clear_color_attachment", "Color Color Attachment Tests"));
1776         de::MovePtr<TestCaseGroup>      depthStencilAttachmentClearTests                (new TestCaseGroup(testCtx, "clear_depth_stencil_attachment", "Color Depth/Stencil Attachment Tests"));
1777         de::MovePtr<TestCaseGroup>      partialColorAttachmentClearTests                (new TestCaseGroup(testCtx, "partial_clear_color_attachment", "Clear Partial Color Attachment Tests"));
1778         de::MovePtr<TestCaseGroup>      partialDepthStencilAttachmentClearTests (new TestCaseGroup(testCtx, "partial_clear_depth_stencil_attachment", "Clear Partial Depth/Stencil Attachment Tests"));
1779
1780         // Some formats are commented out due to the tcu::TextureFormat does not support them yet.
1781         const VkFormat          colorImageFormatsToTest[]       =
1782         {
1783                 VK_FORMAT_R4G4_UNORM_PACK8,
1784                 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
1785                 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
1786                 VK_FORMAT_R5G6B5_UNORM_PACK16,
1787                 VK_FORMAT_B5G6R5_UNORM_PACK16,
1788                 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
1789                 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
1790                 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
1791                 VK_FORMAT_R8_UNORM,
1792                 VK_FORMAT_R8_SNORM,
1793                 VK_FORMAT_R8_USCALED,
1794                 VK_FORMAT_R8_SSCALED,
1795                 VK_FORMAT_R8_UINT,
1796                 VK_FORMAT_R8_SINT,
1797                 VK_FORMAT_R8_SRGB,
1798                 VK_FORMAT_R8G8_UNORM,
1799                 VK_FORMAT_R8G8_SNORM,
1800                 VK_FORMAT_R8G8_USCALED,
1801                 VK_FORMAT_R8G8_SSCALED,
1802                 VK_FORMAT_R8G8_UINT,
1803                 VK_FORMAT_R8G8_SINT,
1804                 VK_FORMAT_R8G8_SRGB,
1805                 VK_FORMAT_R8G8B8_UNORM,
1806                 VK_FORMAT_R8G8B8_SNORM,
1807                 VK_FORMAT_R8G8B8_USCALED,
1808                 VK_FORMAT_R8G8B8_SSCALED,
1809                 VK_FORMAT_R8G8B8_UINT,
1810                 VK_FORMAT_R8G8B8_SINT,
1811                 VK_FORMAT_R8G8B8_SRGB,
1812                 VK_FORMAT_B8G8R8_UNORM,
1813                 VK_FORMAT_B8G8R8_SNORM,
1814                 VK_FORMAT_B8G8R8_USCALED,
1815                 VK_FORMAT_B8G8R8_SSCALED,
1816                 VK_FORMAT_B8G8R8_UINT,
1817                 VK_FORMAT_B8G8R8_SINT,
1818                 VK_FORMAT_B8G8R8_SRGB,
1819                 VK_FORMAT_R8G8B8A8_UNORM,
1820                 VK_FORMAT_R8G8B8A8_SNORM,
1821                 VK_FORMAT_R8G8B8A8_USCALED,
1822                 VK_FORMAT_R8G8B8A8_SSCALED,
1823                 VK_FORMAT_R8G8B8A8_UINT,
1824                 VK_FORMAT_R8G8B8A8_SINT,
1825                 VK_FORMAT_R8G8B8A8_SRGB,
1826                 VK_FORMAT_B8G8R8A8_UNORM,
1827                 VK_FORMAT_B8G8R8A8_SNORM,
1828                 VK_FORMAT_B8G8R8A8_USCALED,
1829                 VK_FORMAT_B8G8R8A8_SSCALED,
1830                 VK_FORMAT_B8G8R8A8_UINT,
1831                 VK_FORMAT_B8G8R8A8_SINT,
1832                 VK_FORMAT_B8G8R8A8_SRGB,
1833                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
1834                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
1835                 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
1836                 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
1837                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
1838                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
1839                 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
1840                 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
1841                 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
1842                 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
1843                 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
1844                 VK_FORMAT_A2R10G10B10_UINT_PACK32,
1845                 VK_FORMAT_A2R10G10B10_SINT_PACK32,
1846                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
1847                 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
1848                 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
1849                 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
1850                 VK_FORMAT_A2B10G10R10_UINT_PACK32,
1851                 VK_FORMAT_A2B10G10R10_SINT_PACK32,
1852                 VK_FORMAT_R16_UNORM,
1853                 VK_FORMAT_R16_SNORM,
1854                 VK_FORMAT_R16_USCALED,
1855                 VK_FORMAT_R16_SSCALED,
1856                 VK_FORMAT_R16_UINT,
1857                 VK_FORMAT_R16_SINT,
1858                 VK_FORMAT_R16_SFLOAT,
1859                 VK_FORMAT_R16G16_UNORM,
1860                 VK_FORMAT_R16G16_SNORM,
1861                 VK_FORMAT_R16G16_USCALED,
1862                 VK_FORMAT_R16G16_SSCALED,
1863                 VK_FORMAT_R16G16_UINT,
1864                 VK_FORMAT_R16G16_SINT,
1865                 VK_FORMAT_R16G16_SFLOAT,
1866                 VK_FORMAT_R16G16B16_UNORM,
1867                 VK_FORMAT_R16G16B16_SNORM,
1868                 VK_FORMAT_R16G16B16_USCALED,
1869                 VK_FORMAT_R16G16B16_SSCALED,
1870                 VK_FORMAT_R16G16B16_UINT,
1871                 VK_FORMAT_R16G16B16_SINT,
1872                 VK_FORMAT_R16G16B16_SFLOAT,
1873                 VK_FORMAT_R16G16B16A16_UNORM,
1874                 VK_FORMAT_R16G16B16A16_SNORM,
1875                 VK_FORMAT_R16G16B16A16_USCALED,
1876                 VK_FORMAT_R16G16B16A16_SSCALED,
1877                 VK_FORMAT_R16G16B16A16_UINT,
1878                 VK_FORMAT_R16G16B16A16_SINT,
1879                 VK_FORMAT_R16G16B16A16_SFLOAT,
1880                 VK_FORMAT_R32_UINT,
1881                 VK_FORMAT_R32_SINT,
1882                 VK_FORMAT_R32_SFLOAT,
1883                 VK_FORMAT_R32G32_UINT,
1884                 VK_FORMAT_R32G32_SINT,
1885                 VK_FORMAT_R32G32_SFLOAT,
1886                 VK_FORMAT_R32G32B32_UINT,
1887                 VK_FORMAT_R32G32B32_SINT,
1888                 VK_FORMAT_R32G32B32_SFLOAT,
1889                 VK_FORMAT_R32G32B32A32_UINT,
1890                 VK_FORMAT_R32G32B32A32_SINT,
1891                 VK_FORMAT_R32G32B32A32_SFLOAT,
1892 //              VK_FORMAT_R64_UINT,
1893 //              VK_FORMAT_R64_SINT,
1894 //              VK_FORMAT_R64_SFLOAT,
1895 //              VK_FORMAT_R64G64_UINT,
1896 //              VK_FORMAT_R64G64_SINT,
1897 //              VK_FORMAT_R64G64_SFLOAT,
1898 //              VK_FORMAT_R64G64B64_UINT,
1899 //              VK_FORMAT_R64G64B64_SINT,
1900 //              VK_FORMAT_R64G64B64_SFLOAT,
1901 //              VK_FORMAT_R64G64B64A64_UINT,
1902 //              VK_FORMAT_R64G64B64A64_SINT,
1903 //              VK_FORMAT_R64G64B64A64_SFLOAT,
1904                 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
1905                 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
1906 //              VK_FORMAT_BC1_RGB_UNORM_BLOCK,
1907 //              VK_FORMAT_BC1_RGB_SRGB_BLOCK,
1908 //              VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
1909 //              VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
1910 //              VK_FORMAT_BC2_UNORM_BLOCK,
1911 //              VK_FORMAT_BC2_SRGB_BLOCK,
1912 //              VK_FORMAT_BC3_UNORM_BLOCK,
1913 //              VK_FORMAT_BC3_SRGB_BLOCK,
1914 //              VK_FORMAT_BC4_UNORM_BLOCK,
1915 //              VK_FORMAT_BC4_SNORM_BLOCK,
1916 //              VK_FORMAT_BC5_UNORM_BLOCK,
1917 //              VK_FORMAT_BC5_SNORM_BLOCK,
1918 //              VK_FORMAT_BC6H_UFLOAT_BLOCK,
1919 //              VK_FORMAT_BC6H_SFLOAT_BLOCK,
1920 //              VK_FORMAT_BC7_UNORM_BLOCK,
1921 //              VK_FORMAT_BC7_SRGB_BLOCK,
1922 //              VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
1923 //              VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
1924 //              VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
1925 //              VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
1926 //              VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
1927 //              VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
1928 //              VK_FORMAT_EAC_R11_UNORM_BLOCK,
1929 //              VK_FORMAT_EAC_R11_SNORM_BLOCK,
1930 //              VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
1931 //              VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
1932 //              VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
1933 //              VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
1934 //              VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
1935 //              VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
1936 //              VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
1937 //              VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
1938 //              VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
1939 //              VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
1940 //              VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
1941 //              VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
1942 //              VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
1943 //              VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
1944 //              VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
1945 //              VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
1946 //              VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
1947 //              VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
1948 //              VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
1949 //              VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
1950 //              VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
1951 //              VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
1952 //              VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
1953 //              VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
1954 //              VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
1955 //              VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
1956 //              VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
1957 //              VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
1958 //              VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
1959 //              VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
1960
1961                 VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT,
1962                 VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT,
1963         };
1964         const size_t    numOfColorImageFormatsToTest                    = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
1965
1966         const VkFormat  depthStencilImageFormatsToTest[]                =
1967         {
1968                 VK_FORMAT_D16_UNORM,
1969                 VK_FORMAT_X8_D24_UNORM_PACK32,
1970                 VK_FORMAT_D32_SFLOAT,
1971                 VK_FORMAT_S8_UINT,
1972                 VK_FORMAT_D16_UNORM_S8_UINT,
1973                 VK_FORMAT_D24_UNORM_S8_UINT,
1974                 VK_FORMAT_D32_SFLOAT_S8_UINT
1975         };
1976         const size_t    numOfDepthStencilImageFormatsToTest             = DE_LENGTH_OF_ARRAY(depthStencilImageFormatsToTest);
1977
1978         struct ClearTestColorParams
1979         {
1980                 bool                            matchTextureChannelClass;
1981                 TextureChannelClass     textureChannelClass;
1982                 const char*                     testNameSuffix;
1983                 float                           clearColors[2][4];
1984                 bool                            useSeparateExpectedColors;
1985                 float                           expectedColors[2][4];
1986         };
1987         const ClearTestColorParams clearColorsToTest[] =
1988         {
1989                 {
1990                         false,                                                                          // matchTextureChannelClass
1991                         TEXTURECHANNELCLASS_LAST,                                       // textureChannelClass
1992                         "",                                                                                     // testNameSuffix
1993                         {
1994                                 { 0.1f, 0.5f, 0.3f, 0.9f },                             // clearColors[0]
1995                                 { 0.3f, 0.6f, 0.2f, 0.7f },                             // clearColors[1]
1996                         },
1997                         false,                                                                          // useSeparateExpectedColors
1998                         { }                                                                                     // expectedColors
1999                 },
2000                 {
2001                         true,                                                                           // matchTextureChannelClass
2002                         TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT,       // textureChannelClass
2003                         "_clamp_input",                                                         // testNameSuffix
2004                         {
2005                                 { -0.1f, -1e6f, -0.3f, -1.5f },                 // clearColors[0]
2006                                 { -1.5f, -0.6f, -1e6f, -0.7f },                 // clearColors[1]
2007                         },
2008                         true,                                                                           // useSeparateExpectedColors
2009                         {
2010                                 { 0.0f, 0.0f, 0.0f, 0.0f },                             // expectedColors[0]
2011                                 { 0.0f, 0.0f, 0.0f, 0.0f },                             // expectedColors[1]
2012                         }
2013                 }
2014         };
2015         const size_t    numOfClearColorsToTest                  = DE_LENGTH_OF_ARRAY(clearColorsToTest);
2016
2017         struct ImageLayerParams
2018         {
2019                 deUint32                imageLayerCount;
2020                 LayerRange              imageViewRange;
2021                 LayerRange              clearLayerRange;
2022                 bool                    twoStep;
2023                 const char*             testName;
2024                 bool                    isCube;
2025         };
2026         const ImageLayerParams imageLayerParamsToTest[] =
2027         {
2028                 {
2029                         1u,                                                                     // imageLayerCount
2030                         {0u, 1u},                                                       // imageViewRange
2031                         {0u, 1u},                                                       // clearLayerRange
2032                         false,                                                          // twoStep
2033                         "single_layer",                                         // testName
2034                         false                                                           // isCube
2035                 },
2036                 {
2037                         16u,                                                            // imageLayerCount
2038                         {3u, 12u},                                                      // imageViewRange
2039                         {2u, 5u},                                                       // clearLayerRange
2040                         false,                                                          // twoStep
2041                         "multiple_layers",                                      // testName
2042                         false                                                           // isCube
2043                 },
2044                 {
2045                         15u,                                                            // imageLayerCount
2046                         { 3u, 6u },                                                     // imageViewRange
2047                         { 2u, 1u },                                                     // clearLayerRange
2048                         false,                                                          // twoStep
2049                         "cube_layers",                                          // testName
2050                         true                                                            // isCube
2051                 },
2052                 {
2053                         16u,                                                            // imageLayerCount
2054                         { 3u, 12u },                                            // imageViewRange
2055                         { 8u, VK_REMAINING_ARRAY_LAYERS },      // clearLayerRange
2056                         false,                                                          // twoStep
2057                         "remaining_array_layers",                       // testName
2058                         false                                                           // isCube
2059                 },
2060                 {
2061                         16u,                                                            // imageLayerCount
2062                         { 3u, 12u },                                            // imageViewRange
2063                         { 8u, VK_REMAINING_ARRAY_LAYERS },      // clearLayerRange
2064                         true,                                                           // twoStep
2065                         "remaining_array_layers_twostep",       // testName
2066                         false                                                           // isCube
2067                 }
2068         };
2069
2070         // Include test cases with VK_REMAINING_ARRAY_LAYERS when using vkCmdClearColorImage
2071         const size_t            numOfImageLayerParamsToTest                     = DE_LENGTH_OF_ARRAY(imageLayerParamsToTest);
2072
2073         // Exclude test cases with VK_REMAINING_ARRAY_LAYERS when using vkCmdClearAttachments
2074         const size_t            numOfAttachmentLayerParamsToTest        = numOfImageLayerParamsToTest - 2;
2075
2076         const VkExtent3D        imageDimensions[]                                       =
2077         {
2078                 { 256,  1,              1},
2079                 { 256,  256,    1},
2080                 { 256,  256,    16},
2081                 { 200,  1,              1},
2082                 { 200,  180,    1},
2083                 { 200,  180,    16},
2084                 { 71,   1,              1},
2085                 { 1,    33,             1},
2086                 { 55,   21,             11},
2087                 { 64,   11,             1},
2088                 { 33,   128,    1},
2089                 { 32,   29,             3}
2090         };
2091
2092         // Clear color image
2093         {
2094                 const VkImageType                       imageTypesToTest[]              =
2095                 {
2096                         VK_IMAGE_TYPE_1D,
2097                         VK_IMAGE_TYPE_2D,
2098                         VK_IMAGE_TYPE_3D
2099                 };
2100                 const size_t                            numOfImageTypesToTest   = DE_LENGTH_OF_ARRAY(imageTypesToTest);
2101
2102                 const VkImageTiling                     imageTilingsToTest[]    =
2103                 {
2104                         VK_IMAGE_TILING_OPTIMAL,
2105                         VK_IMAGE_TILING_LINEAR,
2106                 };
2107                 const size_t                            numOfImageTilingsToTest = DE_LENGTH_OF_ARRAY(imageTilingsToTest);
2108
2109                 for (size_t     imageTypeIndex = 0; imageTypeIndex < numOfImageTypesToTest; ++imageTypeIndex)
2110                 {
2111                         de::MovePtr<TestCaseGroup> imageTypeGroup(new TestCaseGroup(testCtx, getImageTypeCaseName(imageTypesToTest[imageTypeIndex]), ""));
2112
2113                         for (size_t     imageTilingIndex = 0; imageTilingIndex < numOfImageTilingsToTest; ++imageTilingIndex)
2114                         {
2115                                 de::MovePtr<TestCaseGroup> imageTilingGroup(new TestCaseGroup(testCtx, getImageTilingCaseName(imageTilingsToTest[imageTilingIndex]), ""));
2116
2117                                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfImageLayerParamsToTest; ++imageLayerParamsIndex)
2118                                 {
2119                                         // 3D ARRAY images are not supported
2120                                         if (imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount > 1u && imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_3D)
2121                                                 continue;
2122
2123                                         // CUBE images are not tested in clear image tests (they are tested in clear attachment tests)
2124                                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube)
2125                                                 continue;
2126
2127                                         de::MovePtr<TestCaseGroup> imageLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2128
2129                                         for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2130                                         {
2131                                                 const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
2132                                                 const std::string       dimensionsString        = extentToString(dimensions, imageTypesToTest[imageTypeIndex]);
2133
2134                                                 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_1D && dimensions.height > 1)
2135                                                         continue;
2136                                                 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_2D && (dimensions.depth > 1 || dimensions.height == 1))
2137                                                         continue;
2138                                                 if (imageTypesToTest[imageTypeIndex] == VK_IMAGE_TYPE_3D && dimensions.depth == 1)
2139                                                         continue;
2140
2141                                                 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
2142                                                 {
2143                                                         const   VkFormat                        format                  = colorImageFormatsToTest[imageFormatIndex];
2144                                                         const   TextureFormat           tcuFormat               = mapVkFormat(format);
2145                                                         const   TextureChannelClass     channelClass    = getTextureChannelClass(tcuFormat.type);
2146                                                         for (size_t clearColorIndex = 0; clearColorIndex < numOfClearColorsToTest; ++clearColorIndex)
2147                                                         {
2148                                                                 const   ClearTestColorParams&   colorParams             = clearColorsToTest[clearColorIndex];
2149
2150                                                                 if (colorParams.matchTextureChannelClass && channelClass != colorParams.textureChannelClass)
2151                                                                         continue;
2152
2153                                                                 VkClearValue                                    clearColors[2]  =
2154                                                                 {
2155                                                                         makeClearColorValue(format, colorParams.clearColors[0][0], colorParams.clearColors[0][1], colorParams.clearColors[0][2], colorParams.clearColors[0][3]),
2156                                                                         makeClearColorValue(format, colorParams.clearColors[1][0], colorParams.clearColors[1][1], colorParams.clearColors[1][2], colorParams.clearColors[1][3]),
2157                                                                 };
2158                                                                 VkClearValue                                    expectedColors[2];
2159                                                                 if (clearColorsToTest[clearColorIndex].useSeparateExpectedColors)
2160                                                                 {
2161                                                                         expectedColors[0] = makeClearColorValue(format, colorParams.expectedColors[0][0], colorParams.expectedColors[0][1], colorParams.expectedColors[0][2], colorParams.expectedColors[0][3]);
2162                                                                         expectedColors[1] = makeClearColorValue(format, colorParams.expectedColors[1][0], colorParams.expectedColors[1][1], colorParams.expectedColors[1][2], colorParams.expectedColors[1][3]);
2163                                                                 }
2164                                                                 else
2165                                                                 {
2166                                                                         expectedColors[0] = clearColors[0];
2167                                                                         expectedColors[1] = clearColors[1];
2168                                                                 }
2169
2170                                                                 std::string                                             testCaseName    = getFormatCaseName(format) + dimensionsString + colorParams.testNameSuffix;
2171                                                                 TestParams                                              testParams              =
2172                                                                 {
2173                                                                         false,                                                                                                                          // bool                                                         useSingleMipLevel;
2174                                                                         imageTypesToTest[imageTypeIndex],                                                                       // VkImageType                                          imageType;
2175                                                                         format,                                                                                                                         // VkFormat                                                     imageFormat;
2176                                                                         imageTilingsToTest[imageTilingIndex],                                                           // VkImageTiling                                        imageTiling;
2177                                                                         dimensions,                                                                                                                     // VkExtent3D                                           imageExtent;
2178                                                                         imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,          // deUint32                                                     imageLayerCount;
2179                                                                         {
2180                                                                                 0u,
2181                                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
2182                                                                         },                                                                                                                                      // LayerRange                                           imageViewLayerRange;
2183                                                                         makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),                            // VkClearValue                                         initValue;
2184                                                                         {
2185                                                                                 clearColors[0],                                                                                                 // VkClearValue                                         clearValue[0];
2186                                                                                 clearColors[1],                                                                                                 // VkClearValue                                         clearValue[1];
2187                                                                         },
2188                                                                         clearColorsToTest[clearColorIndex].useSeparateExpectedColors,           // bool                                                         useSeparateExpectedClearValue;
2189                                                                         {
2190                                                                                 expectedColors[0],                                                                                              // VkClearValue                                         expectedClearValue[0];
2191                                                                                 expectedColors[1],                                                                                              // VkClearValue                                         expectedClearValue[1];
2192                                                                         },
2193                                                                         imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,          // LayerRange                                           clearLayerRange;
2194                                                                         allocationKind,                                                                                                         // AllocationKind                                       allocationKind;
2195                                                                         false,                                                                                                                          // bool                                                         isCube;
2196                                                                         SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE,                                                        // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
2197                                                                         false,                                                                                                                          // bool                                                         isColorMultipleSubresourceRangeTest;
2198                                                                 };
2199
2200                                                                 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2201                                                                 {
2202                                                                         imageLayersGroup->addChild(new InstanceFactory1<ClearColorImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Image", testParams));
2203
2204                                                                         // Removing linear images as the miplevels may be 1
2205                                                                         if (imageTilingsToTest[imageTilingIndex] == VK_IMAGE_TILING_OPTIMAL)
2206                                                                         {
2207                                                                                 testParams.isColorMultipleSubresourceRangeTest = true;
2208                                                                                 testCaseName += "_multiple_subresourcerange";
2209                                                                                 imageLayersGroup->addChild(new InstanceFactory1<ClearColorImageMultipleSubresourceRangeTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Image with two ranges", testParams));
2210                                                                         }
2211                                                                 }
2212                                                                 else
2213                                                                 {
2214                                                                         imageLayersGroup->addChild(new InstanceFactory1<TwoStepClearColorImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Image", testParams));
2215                                                                 }
2216                                                         }
2217                                                 }
2218                                         }
2219                                         imageTilingGroup->addChild(imageLayersGroup.release());
2220                                 }
2221                                 imageTypeGroup->addChild(imageTilingGroup.release());
2222                         }
2223                         colorImageClearTests->addChild(imageTypeGroup.release());
2224                 }
2225                 imageClearingTests->addChild(colorImageClearTests.release());
2226         }
2227
2228         // Clear depth/stencil image
2229         {
2230                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfImageLayerParamsToTest; ++imageLayerParamsIndex)
2231                 {
2232                         // CUBE images are not tested in clear image tests (they are tested in clear attachment tests)
2233                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube)
2234                                 continue;
2235
2236                         de::MovePtr<TestCaseGroup> imageLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2237
2238                         for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2239                         {
2240                                 const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
2241                                 const std::string       dimensionsString        = extentToString(dimensions, VK_IMAGE_TYPE_2D);
2242
2243                                 if (dimensions.height == 1 || dimensions.depth > 1)
2244                                         continue;
2245
2246                                 for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
2247                                 {
2248                                         const VkFormat  format                                          = depthStencilImageFormatsToTest[imageFormatIndex];
2249                                         const bool              hasDepth                                        = tcu::hasDepthComponent(mapVkFormat(format).order);
2250                                         const bool              hasStencil                                      = tcu::hasStencilComponent(mapVkFormat(format).order);
2251                                         const int               separateLayoutsLoopCount        = (hasDepth && hasStencil) ? 3 : 1;
2252
2253                                         for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
2254                                         {
2255                                                 const std::string       testCaseName    = getFormatCaseName(format) +
2256                                                         ((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
2257                                                          (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
2258                                                          "")
2259                                                         + dimensionsString;
2260                                                 TestParams      testParams              =
2261                                                 {
2262                                                         true,                                                                                                                           // bool                                                         useSingleMipLevel;
2263                                                         VK_IMAGE_TYPE_2D,                                                                                                       // VkImageType                                          imageType;
2264                                                         format,                                                                                                                         // VkFormat                                                     format;
2265                                                         VK_IMAGE_TILING_OPTIMAL,                                                                                        // VkImageTiling                                        tiling;
2266                                                         dimensions,                                                                                                                     // VkExtent3D                                           extent;
2267                                                         imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,          // deUint32                                                     imageLayerCount;
2268                                                         {
2269                                                                 0u,
2270                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
2271                                                         },                                                                                                                                      // LayerRange                                           imageViewLayerRange;
2272                                                         makeClearValueDepthStencil(0.5f, 0x03),                                                         // VkClearValue                                         initValue
2273                                                         {
2274                                                                 makeClearValueDepthStencil(0.1f, 0x06),                                                         // VkClearValue                                         clearValue[0];
2275                                                                 makeClearValueDepthStencil(0.3f, 0x04),                                                         // VkClearValue                                         clearValue[1];
2276                                                         },
2277                                                         false,                                                                                                                          // bool                                                         useSeparateExpectedClearValue;
2278                                                         { },                                                                                                                            // VkClearValue[2]                                      expectedClearValue;
2279                                                         imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,          // LayerRange                                           clearLayerRange;
2280                                                         allocationKind,                                                                                                         // AllocationKind                                       allocationKind;
2281                                                         false,                                                                                                                          // bool                                                         isCube;
2282                                                         SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode),         // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
2283                                                         false,                                                                                                                          // bool                                                         isColorMultipleSubresourceRangeTest;
2284                                                 };
2285
2286                                                 if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2287                                                 {
2288                                                         imageLayersGroup->addChild(new InstanceFactory1<ClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
2289
2290                                                         if (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE && hasDepth && hasStencil)
2291                                                         {
2292                                                                 const std::string       testCaseNameRanges      = getFormatCaseName(format) + dimensionsString + "_multiple_subresourcerange";
2293                                                                 imageLayersGroup->addChild(new InstanceFactory1<ClearDepthStencilImageMultipleSubresourceRangeTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseNameRanges, "Clear Depth/Stencil Image with ranges", testParams));
2294                                                         }
2295                                                 }
2296                                                 else
2297                                                 {
2298                                                         imageLayersGroup->addChild(new InstanceFactory1<TwoStepClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
2299                                                 }
2300                                         }
2301                                 }
2302                         }
2303                         depthStencilImageClearTests->addChild(imageLayersGroup.release());
2304                 }
2305                 imageClearingTests->addChild(depthStencilImageClearTests.release());
2306         }
2307
2308         // Clear color attachment
2309         {
2310                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfAttachmentLayerParamsToTest; ++imageLayerParamsIndex)
2311                 {
2312                         if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2313                         {
2314                                 de::MovePtr<TestCaseGroup> colorAttachmentClearLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2315                                 de::MovePtr<TestCaseGroup> partialColorAttachmentClearLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2316
2317                                 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2318                                 {
2319                                         const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
2320                                         const std::string       dimensionsString        = extentToString(dimensions, VK_IMAGE_TYPE_2D);
2321
2322                                         if (dimensions.height == 1 || dimensions.depth > 1)
2323                                                 continue;
2324
2325                                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube && dimensions.width != dimensions.height)
2326                                                 continue;
2327
2328                                         for (size_t imageFormatIndex = 0; imageFormatIndex < numOfColorImageFormatsToTest; ++imageFormatIndex)
2329                                         {
2330                                                 const   VkFormat                        format                  = colorImageFormatsToTest[imageFormatIndex];
2331                                                 const   TextureFormat           tcuFormat               = mapVkFormat(format);
2332                                                 const   TextureChannelClass     channelClass    = getTextureChannelClass(tcuFormat.type);
2333                                                 for (size_t clearColorIndex = 0; clearColorIndex < numOfClearColorsToTest; ++clearColorIndex)
2334                                                 {
2335                                                         const   ClearTestColorParams&   colorParams             = clearColorsToTest[clearColorIndex];
2336
2337                                                         if (colorParams.matchTextureChannelClass && channelClass != colorParams.textureChannelClass)
2338                                                                 continue;
2339
2340                                                         VkClearValue                                    clearColors[2]  =
2341                                                         {
2342                                                                 makeClearColorValue(format, colorParams.clearColors[0][0], colorParams.clearColors[0][1], colorParams.clearColors[0][2], colorParams.clearColors[0][3]),
2343                                                                 makeClearColorValue(format, colorParams.clearColors[1][0], colorParams.clearColors[1][1], colorParams.clearColors[1][2], colorParams.clearColors[1][3]),
2344                                                         };
2345                                                         VkClearValue                                    expectedColors[2];
2346                                                         if (clearColorsToTest[clearColorIndex].useSeparateExpectedColors)
2347                                                         {
2348                                                                 expectedColors[0] = makeClearColorValue(format, colorParams.expectedColors[0][0], colorParams.expectedColors[0][1], colorParams.expectedColors[0][2], colorParams.expectedColors[0][3]);
2349                                                                 expectedColors[1] = makeClearColorValue(format, colorParams.expectedColors[1][0], colorParams.expectedColors[1][1], colorParams.expectedColors[1][2], colorParams.expectedColors[1][3]);
2350                                                         }
2351                                                         else
2352                                                         {
2353                                                                 expectedColors[0] = clearColors[0];
2354                                                                 expectedColors[1] = clearColors[1];
2355                                                         }
2356
2357                                                         const std::string       testCaseName    = getFormatCaseName(format) + dimensionsString + colorParams.testNameSuffix;
2358                                                         const TestParams        testParams              =
2359                                                         {
2360                                                                 true,                                                                                                                   // bool                                                         useSingleMipLevel;
2361                                                                 VK_IMAGE_TYPE_2D,                                                                                               // VkImageType                                          imageType;
2362                                                                 format,                                                                                                                 // VkFormat                                                     format;
2363                                                                 VK_IMAGE_TILING_OPTIMAL,                                                                                // VkImageTiling                                        tiling;
2364                                                                 dimensions,                                                                                                             // VkExtent3D                                           extent;
2365                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,  // deUint32                                                     imageLayerCount;
2366                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,   // LayerRange                                           imageViewLayerRange;
2367                                                                 makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),                    // VkClearValue                                         initValue
2368                                                                 {
2369                                                                         clearColors[0],                                                                                         // VkClearValue                                         clearValue[0];
2370                                                                         clearColors[1]                                                                                          // VkClearValue                                         clearValue[1];
2371                                                                 },
2372                                                                 colorParams.useSeparateExpectedColors,                                                  // bool                                                         useSeparateExpectedClearValue;
2373                                                                 {
2374                                                                         expectedColors[0],                                                                                      // VkClearValue                                         expectedClearValue[0];
2375                                                                         expectedColors[1]                                                                                       // VkClearValue                                         expectedClearValue[1];
2376                                                                 },
2377                                                                 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,  // LayerRange                                           clearLayerRange;
2378                                                                 allocationKind,                                                                                                 // AllocationKind                                       allocationKind;
2379                                                                 imageLayerParamsToTest[imageLayerParamsIndex].isCube,                   // bool                                                         isCube;
2380                                                                 SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE,                                                // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
2381                                                                 false,                                                                                                                  // bool                                                         isColorMultipleSubresourceRangeTest;
2382                                                         };
2383                                                         colorAttachmentClearLayersGroup->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Attachment", testParams));
2384                                                         if (dimensions.width > 1)
2385                                                                 partialColorAttachmentClearLayersGroup->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Partial Clear Color Attachment", testParams));
2386                                                 }
2387                                         }
2388                                 }
2389                                 colorAttachmentClearTests->addChild(colorAttachmentClearLayersGroup.release());
2390                                 partialColorAttachmentClearTests->addChild(partialColorAttachmentClearLayersGroup.release());
2391                         }
2392                 }
2393                 imageClearingTests->addChild(colorAttachmentClearTests.release());
2394                 imageClearingTests->addChild(partialColorAttachmentClearTests.release());
2395         }
2396
2397         // Clear depth/stencil attachment
2398         {
2399                 for (size_t imageLayerParamsIndex = 0; imageLayerParamsIndex < numOfAttachmentLayerParamsToTest; ++imageLayerParamsIndex)
2400                 {
2401                         if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
2402                         {
2403                                 de::MovePtr<TestCaseGroup> depthStencilLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2404                                 de::MovePtr<TestCaseGroup> partialDepthStencilLayersGroup(new TestCaseGroup(testCtx, imageLayerParamsToTest[imageLayerParamsIndex].testName, ""));
2405
2406                                 for (size_t imageDimensionsIndex = 0; imageDimensionsIndex < DE_LENGTH_OF_ARRAY(imageDimensions); ++imageDimensionsIndex)
2407                                 {
2408                                         const VkExtent3D        dimensions                      = imageDimensions[imageDimensionsIndex];
2409                                         const std::string       dimensionsString        = extentToString(dimensions, VK_IMAGE_TYPE_2D);
2410
2411                                         if (dimensions.height == 1 || dimensions.depth > 1)
2412                                                 continue;
2413
2414                                         if (imageLayerParamsToTest[imageLayerParamsIndex].isCube && dimensions.width != dimensions.height)
2415                                                 continue;
2416
2417                                         for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
2418                                         {
2419                                                 const VkFormat          format                                          = depthStencilImageFormatsToTest[imageFormatIndex];
2420                                                 const bool                      hasDepth                                        = tcu::hasDepthComponent(mapVkFormat(format).order);
2421                                                 const bool                      hasStencil                                      = tcu::hasStencilComponent(mapVkFormat(format).order);
2422                                                 const int                       separateLayoutsLoopCount        = (hasDepth && hasStencil) ? 3 : 1;
2423
2424                                                 for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
2425                                                 {
2426                                                         const std::string       testCaseName    = getFormatCaseName(format) +
2427                                                         ((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
2428                                                          (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
2429                                                          "")
2430                                                         + dimensionsString;
2431
2432                                                         const TestParams        testParams                                              =
2433                                                         {
2434                                                                 true,                                                                                                                   // bool                                                         useSingleMipLevel;
2435                                                                 VK_IMAGE_TYPE_2D,                                                                                               // VkImageType                                          imageType;
2436                                                                 format,                                                                                                                 // VkFormat                                                     format;
2437                                                                 VK_IMAGE_TILING_OPTIMAL,                                                                                // VkImageTiling                                        tiling;
2438                                                                 dimensions,                                                                                                             // VkExtent3D                                           extent;
2439                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,  // deUint32                                                     imageLayerCount;
2440                                                                 imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,   // LayerRange                                           imageViewLayerRange;
2441                                                                 makeClearValueDepthStencil(0.5f, 0x03),                                                 // VkClearValue                                         initValue
2442                                                                 {
2443                                                                         makeClearValueDepthStencil(0.1f, 0x06),                                                 // VkClearValue                                         clearValue[0];
2444                                                                         makeClearValueDepthStencil(0.3f, 0x04),                                                 // VkClearValue                                         clearValue[1];
2445                                                                 },
2446                                                                 false,                                                                                                                  // bool                                                         useSeparateExpectedClearValue;
2447                                                                 { },                                                                                                                    // VkClearValue[2]                                      expectedClearValue;
2448                                                                 imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,  // LayerRange                                           clearLayerRange;
2449                                                                 allocationKind,                                                                                                 // AllocationKind                                       allocationKind;
2450                                                                 imageLayerParamsToTest[imageLayerParamsIndex].isCube,                   // bool                                                         isCube;
2451                                                                 SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode), // SeparateDepthStencilLayoutMode       separateDepthStencilLayoutMode;
2452                                                                 false,                                                                                                                  // bool                                                         isColorMultipleSubresourceRangeTest;
2453                                                         };
2454                                                         depthStencilLayersGroup->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Attachment", testParams));
2455                                                         if (dimensions.width > 1)
2456                                                                 partialDepthStencilLayersGroup->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Partial Clear Depth/Stencil Attachment", testParams));
2457                                                 }
2458                                         }
2459                                 }
2460                                 depthStencilAttachmentClearTests->addChild(depthStencilLayersGroup.release());
2461                                 partialDepthStencilAttachmentClearTests->addChild(partialDepthStencilLayersGroup.release());
2462                         }
2463                 }
2464                 imageClearingTests->addChild(depthStencilAttachmentClearTests.release());
2465                 imageClearingTests->addChild(partialDepthStencilAttachmentClearTests.release());
2466         }
2467
2468         return imageClearingTests;
2469 }
2470
2471 void createCoreImageClearingTests (tcu::TestCaseGroup* group)
2472 {
2473         createImageClearingTestsCommon(group->getTestContext(), group, ALLOCATION_KIND_SUBALLOCATED);
2474 }
2475
2476 void createDedicatedAllocationImageClearingTests (tcu::TestCaseGroup* group)
2477 {
2478         createImageClearingTestsCommon(group->getTestContext(), group, ALLOCATION_KIND_DEDICATED);
2479 }
2480
2481 } // anonymous
2482
2483 TestCaseGroup* createImageClearingTests (TestContext& testCtx)
2484 {
2485         de::MovePtr<TestCaseGroup>      imageClearingTests      (new TestCaseGroup(testCtx, "image_clearing", "Image Clearing Tests"));
2486
2487         imageClearingTests->addChild(createTestGroup(testCtx, "core",                                   "Core Image Clearing Tests",                                                    createCoreImageClearingTests));
2488         imageClearingTests->addChild(createTestGroup(testCtx, "dedicated_allocation",   "Image Clearing Tests For Dedicated Memory Allocation", createDedicatedAllocationImageClearingTests));
2489
2490         return imageClearingTests.release();
2491 }
2492
2493 } // api
2494 } // vkt