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