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