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