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

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