external/vulkancts/modules/vulkan/pipeline/vktPipelineImageTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 Imagination Technologies Ltd.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and/or associated documentation files (the
  10  * "Materials"), to deal in the Materials without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sublicense, and/or sell copies of the Materials, and to
  13  * permit persons to whom the Materials are furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice(s) and this permission notice shall be included
  17  * in all copies or substantial portions of the Materials.
  18  *
  19  * The Materials are Confidential Information as defined by the
  20  * Khronos Membership Agreement until designated non-confidential by Khronos,
  21  * at which point this condition clause shall be removed.
  22  *
  23  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  26  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  27  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  28  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  29  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  30  *
  31  *//*!
  32  * \file
  33  * \brief Image Tests
  34  *//*--------------------------------------------------------------------*/
  35
  36 #include "vktPipelineImageTests.hpp"
  37 #include "vktPipelineImageSamplingInstance.hpp"
  38 #include "vktPipelineImageUtil.hpp"
  39 #include "vktPipelineVertexUtil.hpp"
  40 #include "vktTestCase.hpp"
  41 #include "vkImageUtil.hpp"
  42 #include "vkPrograms.hpp"
  43 #include "tcuTextureUtil.hpp"
  44 #include "deStringUtil.hpp"
  45
  46 #include <sstream>
  47 #include <vector>
  48
  49 namespace vkt
  50 {
  51 namespace pipeline
  52 {
  53
  54 using namespace vk;
  55 using de::MovePtr;
  56
  57 namespace
  58 {
  59
  60 class ImageTest : public vkt::TestCase
  61 {
  62 public:
  63                                                         ImageTest                               (tcu::TestContext&      testContext,
  64                                                                                                          const char*            name,
  65                                                                                                          const char*            description,
  66                                                                                                          VkImageViewType        imageViewType,
  67                                                                                                          VkFormat                       imageFormat,
  68                                                                                                          const tcu::IVec3&      imageSize,
  69                                                                                                          int                            arraySize);
  70
  71         virtual void                    initPrograms                    (SourceCollections& sourceCollections) const;
  72         virtual TestInstance*   createInstance                  (Context& context) const;
  73         static std::string              getGlslSamplerType              (const tcu::TextureFormat& format, VkImageViewType type);
  74
  75 private:
  76         VkImageViewType                 m_imageViewType;
  77         VkFormat                                m_imageFormat;
  78         tcu::IVec3                              m_imageSize;
  79         int                                             m_arraySize;
  80 };
  81
  82 ImageTest::ImageTest (tcu::TestContext& testContext,
  83                                           const char*           name,
  84                                           const char*           description,
  85                                           VkImageViewType       imageViewType,
  86                                           VkFormat                      imageFormat,
  87                                           const tcu::IVec3&     imageSize,
  88                                           int                           arraySize)
  89
  90         : vkt::TestCase         (testContext, name, description)
  91         , m_imageViewType       (imageViewType)
  92         , m_imageFormat         (imageFormat)
  93         , m_imageSize           (imageSize)
  94         , m_arraySize           (arraySize)
  95 {
  96 }
  97
  98 void ImageTest::initPrograms (SourceCollections& sourceCollections) const
  99 {
 100         std::ostringstream                              vertexSrc;
 101         std::ostringstream                              fragmentSrc;
 102         const char*                                             texCoordSwizzle = DE_NULL;
 103         const tcu::TextureFormat                format                  = (isCompressedFormat(m_imageFormat)) ? tcu::getUncompressedFormat(mapVkCompressedFormat(m_imageFormat))
 104                                                                                                                                                                                   : mapVkFormat(m_imageFormat);
 105         const tcu::TextureFormatInfo    formatInfo              = tcu::getTextureFormatInfo(format);
 106
 107         switch (m_imageViewType)
 108         {
 109                 case VK_IMAGE_VIEW_TYPE_1D:
 110                         texCoordSwizzle = "x";
 111                         break;
 112                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 113                 case VK_IMAGE_VIEW_TYPE_2D:
 114                         texCoordSwizzle = "xy";
 115                         break;
 116                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 117                 case VK_IMAGE_VIEW_TYPE_3D:
 118                 case VK_IMAGE_VIEW_TYPE_CUBE:
 119                         texCoordSwizzle = "xyz";
 120                         break;
 121                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 122                         texCoordSwizzle = "xyzw";
 123                         break;
 124                 default:
 125                         DE_ASSERT(false);
 126                         break;
 127         }
 128
 129         vertexSrc << "#version 440\n"
 130                           << "layout(location = 0) in vec4 position;\n"
 131                           << "layout(location = 1) in vec4 texCoords;\n"
 132                           << "layout(location = 0) out highp vec4 vtxTexCoords;\n"
 133                           << "out gl_PerVertex {\n"
 134                           << "  vec4 gl_Position;\n"
 135                           << "};\n"
 136                           << "void main (void)\n"
 137                           << "{\n"
 138                           << "  gl_Position = position;\n"
 139                           << "  vtxTexCoords = texCoords;\n"
 140                           << "}\n";
 141
 142         fragmentSrc << "#version 440\n"
 143                                 << "layout(set = 0, binding = 0) uniform highp " << getGlslSamplerType(format, m_imageViewType) << " texSampler;\n"
 144                                 << "layout(location = 0) in highp vec4 vtxTexCoords;\n"
 145                                 << "layout(location = 0) out highp vec4 fragColor;\n"
 146                                 << "void main (void)\n"
 147                                 << "{\n"
 148                                 << "    fragColor = (texture(texSampler, vtxTexCoords." << texCoordSwizzle << std::scientific << ") * vec4" << formatInfo.lookupScale << ") + vec4" << formatInfo.lookupBias << ";\n"
 149                                 << "}\n";
 150
 151         sourceCollections.glslSources.add("tex_vert") << glu::VertexSource(vertexSrc.str());
 152         sourceCollections.glslSources.add("tex_frag") << glu::FragmentSource(fragmentSrc.str());
 153 }
 154
 155 TestInstance* ImageTest::createInstance (Context& context) const
 156 {
 157         tcu::IVec2 renderSize;
 158
 159         if (m_imageViewType == VK_IMAGE_VIEW_TYPE_1D || m_imageViewType == VK_IMAGE_VIEW_TYPE_2D)
 160         {
 161                 renderSize = tcu::IVec2(m_imageSize.x(), m_imageSize.y());
 162         }
 163         else
 164         {
 165                 // Draw a 3x2 grid of texture layers
 166                 renderSize = tcu::IVec2(m_imageSize.x() * 3, m_imageSize.y() * 2);
 167         }
 168
 169         const std::vector<Vertex4Tex4>  vertices                        = createTestQuadMosaic(m_imageViewType);
 170         const VkComponentMapping                componentMapping        = getFormatComponentMapping(m_imageFormat);
 171         const VkImageSubresourceRange   subresourceRange        =
 172         {
 173                 VK_IMAGE_ASPECT_COLOR_BIT,
 174                 0u,
 175                 (deUint32)deLog2Floor32(deMax32(m_imageSize.x(), deMax32(m_imageSize.y(), m_imageSize.z()))) + 1,
 176                 0u,
 177                 (deUint32)m_arraySize,
 178         };
 179
 180         const VkSamplerCreateInfo samplerParams =
 181         {
 182                 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,                                                                  // VkStructureType                      sType;
 183                 DE_NULL,                                                                                                                                // const void*                          pNext;
 184                 0u,                                                                                                                                             // VkSamplerCreateFlags         flags;
 185                 VK_FILTER_NEAREST,                                                                                                              // VkFilter                                     magFilter;
 186                 VK_FILTER_NEAREST,                                                                                                              // VkFilter                                     minFilter;
 187                 VK_SAMPLER_MIPMAP_MODE_NEAREST,                                                                                 // VkSamplerMipmapMode          mipmapMode;
 188                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                                  // VkSamplerAddressMode         addressModeU;
 189                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                                  // VkSamplerAddressMode         addressModeV;
 190                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                                  // VkSamplerAddressMode         addressModeW;
 191                 0.0f,                                                                                                                                   // float                                        mipLodBias;
 192                 1.0f,                                                                                                                                   // float                                        maxAnisotropy;
 193                 false,                                                                                                                                  // VkBool32                                     compareEnable;
 194                 VK_COMPARE_OP_NEVER,                                                                                                    // VkCompareOp                          compareOp;
 195                 0.0f,                                                                                                                                   // float                                        minLod;
 196                 (float)(subresourceRange.levelCount - 1),                                                               // float                                        maxLod;
 197                 getFormatBorderColor(BORDER_COLOR_TRANSPARENT_BLACK, m_imageFormat),    // VkBorderColor                        borderColor;
 198                 false                                                                                                                                   // VkBool32                                     unnormalizedCoordinates;
 199         };
 200
 201         return new ImageSamplingInstance(context, renderSize, m_imageViewType, m_imageFormat, m_imageSize, m_arraySize, componentMapping, subresourceRange, samplerParams, 0.0f, vertices);
 202 }
 203
 204 std::string ImageTest::getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
 205 {
 206         std::ostringstream samplerType;
 207
 208         if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
 209                 samplerType << "u";
 210         else if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
 211                 samplerType << "i";
 212
 213         switch (type)
 214         {
 215                 case VK_IMAGE_VIEW_TYPE_1D:
 216                         samplerType << "sampler1D";
 217                         break;
 218
 219                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 220                         samplerType << "sampler1DArray";
 221                         break;
 222
 223                 case VK_IMAGE_VIEW_TYPE_2D:
 224                         samplerType << "sampler2D";
 225                         break;
 226
 227                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 228                         samplerType << "sampler2DArray";
 229                         break;
 230
 231                 case VK_IMAGE_VIEW_TYPE_3D:
 232                         samplerType << "sampler3D";
 233                         break;
 234
 235                 case VK_IMAGE_VIEW_TYPE_CUBE:
 236                         samplerType << "samplerCube";
 237                         break;
 238
 239                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 240                         samplerType << "samplerCubeArray";
 241                         break;
 242
 243                 default:
 244                         DE_FATAL("Unknown image view type");
 245                         break;
 246         }
 247
 248         return samplerType.str();
 249 }
 250
 251 std::string getFormatCaseName (const VkFormat format)
 252 {
 253         const std::string       fullName        = getFormatName(format);
 254
 255         DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
 256
 257         return de::toLower(fullName.substr(10));
 258 }
 259
 260 std::string getSizeName (VkImageViewType viewType, const tcu::IVec3& size, int arraySize)
 261 {
 262         std::ostringstream      caseName;
 263
 264         switch (viewType)
 265         {
 266                 case VK_IMAGE_VIEW_TYPE_1D:
 267                 case VK_IMAGE_VIEW_TYPE_2D:
 268                 case VK_IMAGE_VIEW_TYPE_CUBE:
 269                         caseName << size.x() << "x" << size.y();
 270                         break;
 271
 272                 case VK_IMAGE_VIEW_TYPE_3D:
 273                         caseName << size.x() << "x" << size.y() << "x" << size.z();
 274                         break;
 275
 276                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 277                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 278                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 279                         caseName << size.x() << "x" << size.y() << "_array_of_" << arraySize;
 280                         break;
 281
 282                 default:
 283                         DE_ASSERT(false);
 284                         break;
 285         }
 286
 287         return caseName.str();
 288 }
 289
 290 de::MovePtr<tcu::TestCaseGroup> createImageSizeTests (tcu::TestContext& testCtx, VkImageViewType imageViewType, VkFormat imageFormat)
 291 {
 292         using tcu::IVec3;
 293
 294         std::vector<IVec3>                                      imageSizes;
 295         std::vector<int>                                        arraySizes;
 296         de::MovePtr<tcu::TestCaseGroup>         imageSizeTests  (new tcu::TestCaseGroup(testCtx, "size", ""));
 297
 298         // Select image imageSizes
 299         switch (imageViewType)
 300         {
 301                 case VK_IMAGE_VIEW_TYPE_1D:
 302                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 303                         // POT
 304                         imageSizes.push_back(IVec3(1, 1, 1));
 305                         imageSizes.push_back(IVec3(2, 1, 1));
 306                         imageSizes.push_back(IVec3(32, 1, 1));
 307                         imageSizes.push_back(IVec3(128, 1, 1));
 308                         imageSizes.push_back(IVec3(512, 1, 1));
 309
 310                         // NPOT
 311                         imageSizes.push_back(IVec3(3, 1, 1));
 312                         imageSizes.push_back(IVec3(13, 1, 1));
 313                         imageSizes.push_back(IVec3(127, 1, 1));
 314                         imageSizes.push_back(IVec3(443, 1, 1));
 315                         break;
 316
 317                 case VK_IMAGE_VIEW_TYPE_2D:
 318                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 319                         // POT
 320                         imageSizes.push_back(IVec3(1, 1, 1));
 321                         imageSizes.push_back(IVec3(2, 2, 1));
 322                         imageSizes.push_back(IVec3(32, 32, 1));
 323
 324                         // NPOT
 325                         imageSizes.push_back(IVec3(3, 3, 1));
 326                         imageSizes.push_back(IVec3(13, 13, 1));
 327
 328                         // POT rectangular
 329                         imageSizes.push_back(IVec3(8, 16, 1));
 330                         imageSizes.push_back(IVec3(32, 16, 1));
 331
 332                         // NPOT rectangular
 333                         imageSizes.push_back(IVec3(13, 23, 1));
 334                         imageSizes.push_back(IVec3(23, 8, 1));
 335                         break;
 336
 337                 case VK_IMAGE_VIEW_TYPE_3D:
 338                         // POT cube
 339                         imageSizes.push_back(IVec3(1, 1, 1));
 340                         imageSizes.push_back(IVec3(2, 2, 2));
 341                         imageSizes.push_back(IVec3(16, 16, 16));
 342
 343                         // POT non-cube
 344                         imageSizes.push_back(IVec3(32, 16, 8));
 345                         imageSizes.push_back(IVec3(8, 16, 32));
 346                         break;
 347
 348                 case VK_IMAGE_VIEW_TYPE_CUBE:
 349                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 350                         // POT
 351                         imageSizes.push_back(IVec3(32, 32, 1));
 352
 353                         // NPOT
 354                         imageSizes.push_back(IVec3(13, 13, 1));
 355                         break;
 356
 357                 default:
 358                         DE_ASSERT(false);
 359                         break;
 360         }
 361
 362         // Select array sizes
 363         switch (imageViewType)
 364         {
 365                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 366                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 367                         arraySizes.push_back(3);
 368                         arraySizes.push_back(6);
 369                         break;
 370
 371                 case VK_IMAGE_VIEW_TYPE_CUBE:
 372                         arraySizes.push_back(6);
 373                         break;
 374
 375                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 376                         arraySizes.push_back(6);
 377                         arraySizes.push_back(6 * 6);
 378                         break;
 379
 380                 default:
 381                         arraySizes.push_back(1);
 382                         break;
 383         }
 384
 385         for (size_t sizeNdx = 0; sizeNdx < imageSizes.size(); sizeNdx++)
 386         {
 387                 for (size_t arraySizeNdx = 0; arraySizeNdx < arraySizes.size(); arraySizeNdx++)
 388                 {
 389                         imageSizeTests->addChild(new ImageTest(testCtx,
 390                                                                                                    getSizeName(imageViewType, imageSizes[sizeNdx], arraySizes[arraySizeNdx]).c_str(),
 391                                                                                                    "",
 392                                                                                                    imageViewType,
 393                                                                                                    imageFormat,
 394                                                                                                    imageSizes[sizeNdx],
 395                                                                                                    arraySizes[arraySizeNdx]));
 396                 }
 397         }
 398
 399         return imageSizeTests;
 400 }
 401
 402 } // anonymous
 403
 404 tcu::TestCaseGroup* createImageTests (tcu::TestContext& testCtx)
 405 {
 406         const struct
 407         {
 408                 VkImageViewType         type;
 409                 const char*                     name;
 410         }
 411         imageViewTypes[] =
 412         {
 413                 { VK_IMAGE_VIEW_TYPE_1D,                        "1d" },
 414                 { VK_IMAGE_VIEW_TYPE_1D_ARRAY,          "1d_array" },
 415                 { VK_IMAGE_VIEW_TYPE_2D,                        "2d" },
 416                 { VK_IMAGE_VIEW_TYPE_2D_ARRAY,          "2d_array" },
 417                 { VK_IMAGE_VIEW_TYPE_3D,                        "3d" },
 418                 { VK_IMAGE_VIEW_TYPE_CUBE,                      "cube" },
 419                 { VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,        "cube_array" }
 420         };
 421
 422         // All supported dEQP formats that are not intended for depth or stencil.
 423         const VkFormat formats[] =
 424         {
 425                 VK_FORMAT_R4G4_UNORM_PACK8,
 426                 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
 427                 VK_FORMAT_R5G6B5_UNORM_PACK16,
 428                 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
 429                 VK_FORMAT_R8_UNORM,
 430                 VK_FORMAT_R8_SNORM,
 431                 VK_FORMAT_R8_USCALED,
 432                 VK_FORMAT_R8_SSCALED,
 433                 VK_FORMAT_R8_UINT,
 434                 VK_FORMAT_R8_SINT,
 435                 VK_FORMAT_R8_SRGB,
 436                 VK_FORMAT_R8G8_UNORM,
 437                 VK_FORMAT_R8G8_SNORM,
 438                 VK_FORMAT_R8G8_USCALED,
 439                 VK_FORMAT_R8G8_SSCALED,
 440                 VK_FORMAT_R8G8_UINT,
 441                 VK_FORMAT_R8G8_SINT,
 442                 VK_FORMAT_R8G8_SRGB,
 443                 VK_FORMAT_R8G8B8_UNORM,
 444                 VK_FORMAT_R8G8B8_SNORM,
 445                 VK_FORMAT_R8G8B8_USCALED,
 446                 VK_FORMAT_R8G8B8_SSCALED,
 447                 VK_FORMAT_R8G8B8_UINT,
 448                 VK_FORMAT_R8G8B8_SINT,
 449                 VK_FORMAT_R8G8B8_SRGB,
 450                 VK_FORMAT_R8G8B8A8_UNORM,
 451                 VK_FORMAT_R8G8B8A8_SNORM,
 452                 VK_FORMAT_R8G8B8A8_USCALED,
 453                 VK_FORMAT_R8G8B8A8_SSCALED,
 454                 VK_FORMAT_R8G8B8A8_UINT,
 455                 VK_FORMAT_R8G8B8A8_SINT,
 456                 VK_FORMAT_R8G8B8A8_SRGB,
 457                 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
 458                 VK_FORMAT_A2R10G10B10_UINT_PACK32,
 459                 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
 460                 VK_FORMAT_R16_UNORM,
 461                 VK_FORMAT_R16_SNORM,
 462                 VK_FORMAT_R16_USCALED,
 463                 VK_FORMAT_R16_SSCALED,
 464                 VK_FORMAT_R16_UINT,
 465                 VK_FORMAT_R16_SINT,
 466                 VK_FORMAT_R16_SFLOAT,
 467                 VK_FORMAT_R16G16_UNORM,
 468                 VK_FORMAT_R16G16_SNORM,
 469                 VK_FORMAT_R16G16_USCALED,
 470                 VK_FORMAT_R16G16_SSCALED,
 471                 VK_FORMAT_R16G16_UINT,
 472                 VK_FORMAT_R16G16_SINT,
 473                 VK_FORMAT_R16G16_SFLOAT,
 474                 VK_FORMAT_R16G16B16_UNORM,
 475                 VK_FORMAT_R16G16B16_SNORM,
 476                 VK_FORMAT_R16G16B16_USCALED,
 477                 VK_FORMAT_R16G16B16_SSCALED,
 478                 VK_FORMAT_R16G16B16_UINT,
 479                 VK_FORMAT_R16G16B16_SINT,
 480                 VK_FORMAT_R16G16B16_SFLOAT,
 481                 VK_FORMAT_R16G16B16A16_UNORM,
 482                 VK_FORMAT_R16G16B16A16_SNORM,
 483                 VK_FORMAT_R16G16B16A16_USCALED,
 484                 VK_FORMAT_R16G16B16A16_SSCALED,
 485                 VK_FORMAT_R16G16B16A16_UINT,
 486                 VK_FORMAT_R16G16B16A16_SINT,
 487                 VK_FORMAT_R16G16B16A16_SFLOAT,
 488                 VK_FORMAT_R32_UINT,
 489                 VK_FORMAT_R32_SINT,
 490                 VK_FORMAT_R32_SFLOAT,
 491                 VK_FORMAT_R32G32_UINT,
 492                 VK_FORMAT_R32G32_SINT,
 493                 VK_FORMAT_R32G32_SFLOAT,
 494                 VK_FORMAT_R32G32B32_UINT,
 495                 VK_FORMAT_R32G32B32_SINT,
 496                 VK_FORMAT_R32G32B32_SFLOAT,
 497                 VK_FORMAT_R32G32B32A32_UINT,
 498                 VK_FORMAT_R32G32B32A32_SINT,
 499                 VK_FORMAT_R32G32B32A32_SFLOAT,
 500                 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
 501                 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
 502                 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
 503                 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
 504
 505                 // Compressed formats
 506                 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
 507                 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
 508                 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
 509                 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
 510                 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
 511                 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
 512                 VK_FORMAT_EAC_R11_UNORM_BLOCK,
 513                 VK_FORMAT_EAC_R11_SNORM_BLOCK,
 514                 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
 515                 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
 516                 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
 517                 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
 518                 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
 519                 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
 520                 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
 521                 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
 522                 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
 523                 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
 524                 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
 525                 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
 526                 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
 527                 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
 528                 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
 529                 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
 530                 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
 531                 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
 532                 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
 533                 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
 534                 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
 535                 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
 536                 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
 537                 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
 538                 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
 539                 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
 540                 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
 541                 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
 542                 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
 543                 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
 544         };
 545
 546         de::MovePtr<tcu::TestCaseGroup> imageTests                      (new tcu::TestCaseGroup(testCtx, "image", "Image tests"));
 547         de::MovePtr<tcu::TestCaseGroup> viewTypeTests           (new tcu::TestCaseGroup(testCtx, "view_type", ""));
 548
 549         for (int viewTypeNdx = 0; viewTypeNdx < DE_LENGTH_OF_ARRAY(imageViewTypes); viewTypeNdx++)
 550         {
 551                 const VkImageViewType                   viewType                = imageViewTypes[viewTypeNdx].type;
 552                 de::MovePtr<tcu::TestCaseGroup> viewTypeGroup   (new tcu::TestCaseGroup(testCtx, imageViewTypes[viewTypeNdx].name, (std::string("Uses a ") + imageViewTypes[viewTypeNdx].name + " view").c_str()));
 553                 de::MovePtr<tcu::TestCaseGroup> formatTests             (new tcu::TestCaseGroup(testCtx, "format", "Tests samplable formats"));
 554
 555                 for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
 556                 {
 557                         const VkFormat  format  = formats[formatNdx];
 558
 559                         if (isCompressedFormat(format))
 560                         {
 561                                 // Do not use compressed formats with 1D and 1D array textures.
 562                                 if (viewType == VK_IMAGE_VIEW_TYPE_1D || viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY)
 563                                         break;
 564
 565                                 // 3D ASTC textures are not supported.
 566                                 if (tcu::isAstcFormat(mapVkCompressedFormat(format)) && viewType == VK_IMAGE_VIEW_TYPE_3D)
 567                                         break;
 568                         }
 569
 570                         de::MovePtr<tcu::TestCaseGroup> formatGroup     (new tcu::TestCaseGroup(testCtx,
 571                                                                                                                                                                 getFormatCaseName(format).c_str(),
 572                                                                                                                                                                 (std::string("Samples a texture of format ") + getFormatName(format)).c_str()));
 573
 574                         de::MovePtr<tcu::TestCaseGroup> sizeTests = createImageSizeTests(testCtx, viewType, format);
 575
 576                         formatGroup->addChild(sizeTests.release());
 577                         formatTests->addChild(formatGroup.release());
 578                 }
 579
 580                 viewTypeGroup->addChild(formatTests.release());
 581                 viewTypeTests->addChild(viewTypeGroup.release());
 582         }
 583
 584         imageTests->addChild(viewTypeTests.release());
 585
 586         return imageTests.release();
 587 }
 588
 589 } // pipeline
 590 } // vkt