external/vulkancts/modules/vulkan/pipeline/vktPipelineSamplerTests.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  * 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 Sampler Tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktPipelineSamplerTests.hpp"
  26 #include "vktPipelineImageSamplingInstance.hpp"
  27 #include "vktPipelineImageUtil.hpp"
  28 #include "vktPipelineVertexUtil.hpp"
  29 #include "vktTestCase.hpp"
  30 #include "vkImageUtil.hpp"
  31 #include "vkPrograms.hpp"
  32 #include "tcuPlatform.hpp"
  33 #include "tcuTextureUtil.hpp"
  34 #include "deStringUtil.hpp"
  35 #include "deMemory.h"
  36
  37 #include <iomanip>
  38 #include <sstream>
  39 #include <vector>
  40
  41 namespace vkt
  42 {
  43 namespace pipeline
  44 {
  45
  46 using namespace vk;
  47 using de::MovePtr;
  48
  49 namespace
  50 {
  51
  52 class SamplerTest : public vkt::TestCase
  53 {
  54 public:
  55                                                                                 SamplerTest                             (tcu::TestContext&      testContext,
  56                                                                                                                                  const char*            name,
  57                                                                                                                                  const char*            description,
  58                                                                                                                                  VkImageViewType        imageViewType,
  59                                                                                                                                  VkFormat                       imageFormat,
  60                                                                                                                                  int                            imageSize,
  61                                                                                                                                  float                          samplerLod);
  62         virtual                                                         ~SamplerTest                    (void) {}
  63
  64         virtual void                                            initPrograms                    (SourceCollections& sourceCollections) const;
  65         virtual TestInstance*                           createInstance                  (Context& context) const;
  66         virtual tcu::UVec2                                      getRenderSize                   (VkImageViewType viewType) const;
  67         virtual std::vector<Vertex4Tex4>        createVertices                  (void) const;
  68         virtual VkSamplerCreateInfo                     getSamplerCreateInfo    (void) const;
  69
  70         static std::string                                      getGlslSamplerType              (const tcu::TextureFormat& format, VkImageViewType type);
  71         static tcu::IVec3                                       getImageSize                    (VkImageViewType viewType, int size);
  72         static int                                                      getArraySize                    (VkImageViewType viewType);
  73
  74 protected:
  75         VkImageViewType                                         m_imageViewType;
  76         VkFormat                                                        m_imageFormat;
  77         int                                                                     m_imageSize;
  78         VkImageViewCreateInfo                           m_imageViewParams;
  79         VkSamplerCreateInfo                                     m_samplerParams;
  80         float                                                           m_samplerLod;
  81 };
  82
  83 class SamplerMagFilterTest : public SamplerTest
  84 {
  85 public:
  86                                                                         SamplerMagFilterTest    (tcu::TestContext&      testContext,
  87                                                                                                                          const char*            name,
  88                                                                                                                          const char*            description,
  89                                                                                                                          VkImageViewType        imageViewType,
  90                                                                                                                          VkFormat                       imageFormat,
  91                                                                                                                          VkFilter                       magFilter);
  92         virtual                                                 ~SamplerMagFilterTest   (void) {}
  93         virtual VkSamplerCreateInfo             getSamplerCreateInfo    (void) const;
  94
  95 private:
  96         VkFilter                                                m_magFilter;
  97 };
  98
  99 class SamplerMinFilterTest : public SamplerTest
 100 {
 101 public:
 102                                                                         SamplerMinFilterTest    (tcu::TestContext&      testContext,
 103                                                                                                                          const char*            name,
 104                                                                                                                          const char*            description,
 105                                                                                                                          VkImageViewType        imageViewType,
 106                                                                                                                          VkFormat                       imageFormat,
 107                                                                                                                          VkFilter                       minFilter);
 108         virtual                                                 ~SamplerMinFilterTest   (void) {}
 109         virtual VkSamplerCreateInfo             getSamplerCreateInfo    (void) const;
 110
 111 private:
 112         VkFilter                                                m_minFilter;
 113 };
 114
 115 class SamplerLodTest : public SamplerTest
 116 {
 117 public:
 118                                                                         SamplerLodTest                  (tcu::TestContext&              testContext,
 119                                                                                                                          const char*                    name,
 120                                                                                                                          const char*                    description,
 121                                                                                                                          VkImageViewType                imageViewType,
 122                                                                                                                          VkFormat                               imageFormat,
 123                                                                                                                          VkSamplerMipmapMode    mipmapMode,
 124                                                                                                                          float                                  minLod,
 125                                                                                                                          float                                  maxLod,
 126                                                                                                                          float                                  mipLodBias,
 127                                                                                                                          float                                  samplerLod);
 128         virtual                                                 ~SamplerLodTest                 (void) {}
 129         virtual VkSamplerCreateInfo             getSamplerCreateInfo    (void) const;
 130
 131 private:
 132         VkSamplerMipmapMode                             m_mipmapMode;
 133         float                                                   m_minLod;
 134         float                                                   m_maxLod;
 135         float                                                   m_mipLodBias;
 136 };
 137
 138 class SamplerAddressModesTest : public SamplerTest
 139 {
 140 public:
 141                                                                                 SamplerAddressModesTest         (tcu::TestContext&              testContext,
 142                                                                                                                                          const char*                    name,
 143                                                                                                                                          const char*                    description,
 144                                                                                                                                          VkImageViewType                imageViewType,
 145                                                                                                                                          VkFormat                               imageFormat,
 146                                                                                                                                          VkSamplerAddressMode   addressU,
 147                                                                                                                                          VkSamplerAddressMode   addressV,
 148                                                                                                                                          VkSamplerAddressMode   addressW,
 149                                                                                                                                          VkBorderColor                  borderColor);
 150         virtual                                                         ~SamplerAddressModesTest        (void) {}
 151         virtual tcu::UVec2                                      getRenderSize                           (VkImageViewType viewType) const;
 152         virtual std::vector<Vertex4Tex4>        createVertices                          (void) const;
 153         virtual VkSamplerCreateInfo                     getSamplerCreateInfo            (void) const;
 154
 155 private:
 156         VkSamplerAddressMode                            m_addressU;
 157         VkSamplerAddressMode                            m_addressV;
 158         VkSamplerAddressMode                            m_addressW;
 159         VkBorderColor                                           m_borderColor;
 160 };
 161
 162
 163 // SamplerTest
 164
 165 SamplerTest::SamplerTest (tcu::TestContext&     testContext,
 166                                                   const char*           name,
 167                                                   const char*           description,
 168                                                   VkImageViewType       imageViewType,
 169                                                   VkFormat                      imageFormat,
 170                                                   int                           imageSize,
 171                                                   float                         samplerLod)
 172         : vkt::TestCase         (testContext, name, description)
 173         , m_imageViewType       (imageViewType)
 174         , m_imageFormat         (imageFormat)
 175         , m_imageSize           (imageSize)
 176         , m_samplerLod          (samplerLod)
 177 {
 178 }
 179
 180 void SamplerTest::initPrograms (SourceCollections& sourceCollections) const
 181 {
 182         std::ostringstream                              vertexSrc;
 183         std::ostringstream                              fragmentSrc;
 184         const char*                                             texCoordSwizzle = DE_NULL;
 185         tcu::TextureFormat                              format                  = (isCompressedFormat(m_imageFormat)) ? tcu::getUncompressedFormat(mapVkCompressedFormat(m_imageFormat))
 186                                                                                                                                                                                   : mapVkFormat(m_imageFormat);
 187         tcu::Vec4                                               lookupScale;
 188         tcu::Vec4                                               lookupBias;
 189
 190         getLookupScaleBias(m_imageFormat, lookupScale, lookupBias);
 191
 192         switch (m_imageViewType)
 193         {
 194                 case VK_IMAGE_VIEW_TYPE_1D:
 195                         texCoordSwizzle = "x";
 196                         break;
 197                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 198                 case VK_IMAGE_VIEW_TYPE_2D:
 199                         texCoordSwizzle = "xy";
 200                         break;
 201                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 202                 case VK_IMAGE_VIEW_TYPE_3D:
 203                 case VK_IMAGE_VIEW_TYPE_CUBE:
 204                         texCoordSwizzle = "xyz";
 205                         break;
 206                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 207                         texCoordSwizzle = "xyzw";
 208                         break;
 209                 default:
 210                         DE_ASSERT(false);
 211                         break;
 212         }
 213
 214         vertexSrc << "#version 440\n"
 215                           << "layout(location = 0) in vec4 position;\n"
 216                           << "layout(location = 1) in vec4 texCoords;\n"
 217                           << "layout(location = 0) out highp vec4 vtxTexCoords;\n"
 218                           << "out gl_PerVertex {\n"
 219                           << "  vec4 gl_Position;\n"
 220                           << "};\n"
 221                           << "void main (void)\n"
 222                           << "{\n"
 223                           << "  gl_Position = position;\n"
 224                           << "  vtxTexCoords = texCoords;\n"
 225                           << "}\n";
 226
 227         fragmentSrc << "#version 440\n"
 228                                 << "layout(set = 0, binding = 0) uniform highp " << getGlslSamplerType(format, m_imageViewType) << " texSampler;\n"
 229                                 << "layout(location = 0) in highp vec4 vtxTexCoords;\n"
 230                                 << "layout(location = 0) out highp vec4 fragColor;\n"
 231                                 << "void main (void)\n"
 232                                 << "{\n"
 233                                 << "    fragColor = ";
 234
 235         if (m_samplerLod > 0.0f)
 236                 fragmentSrc << "textureLod(texSampler, vtxTexCoords." << texCoordSwizzle << ", " << std::fixed <<  m_samplerLod << ")";
 237         else
 238                 fragmentSrc << "texture(texSampler, vtxTexCoords." << texCoordSwizzle << ")" << std::fixed;
 239
 240         fragmentSrc << " * vec4" << std::scientific << lookupScale << " + vec4" << lookupBias << ";\n"
 241                                 << "}\n";
 242
 243         sourceCollections.glslSources.add("tex_vert") << glu::VertexSource(vertexSrc.str());
 244         sourceCollections.glslSources.add("tex_frag") << glu::FragmentSource(fragmentSrc.str());
 245 }
 246
 247 TestInstance* SamplerTest::createInstance (Context& context) const
 248 {
 249         const tcu::UVec2                                renderSize                      = getRenderSize(m_imageViewType);
 250         const std::vector<Vertex4Tex4>  vertices                        = createVertices();
 251         const VkSamplerCreateInfo               samplerParams           = getSamplerCreateInfo();
 252         const VkComponentMapping                componentMapping        = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
 253         const VkImageSubresourceRange   subresourceRange        =
 254         {
 255                 VK_IMAGE_ASPECT_COLOR_BIT,                                                              // VkImageAspectFlags   aspectMask;
 256                 0u,                                                                                                             // deUint32                             baseMipLevel;
 257                 (deUint32)deLog2Floor32(m_imageSize) + 1,                               // deUint32                             mipLevels;
 258                 0u,                                                                                                             // deUint32                             baseArrayLayer;
 259                 (deUint32)SamplerTest::getArraySize(m_imageViewType)    // deUint32                             arraySize;
 260         };
 261
 262
 263
 264         return new ImageSamplingInstance(context, renderSize, m_imageViewType, m_imageFormat,
 265                                                                          getImageSize(m_imageViewType, m_imageSize),
 266                                                                          getArraySize(m_imageViewType),
 267                                                                          componentMapping, subresourceRange,
 268                                                                          samplerParams, m_samplerLod,vertices);
 269 }
 270
 271 tcu::UVec2 SamplerTest::getRenderSize (VkImageViewType viewType) const
 272 {
 273         if (viewType == VK_IMAGE_VIEW_TYPE_1D || viewType == VK_IMAGE_VIEW_TYPE_2D)
 274         {
 275                 return tcu::UVec2(16u, 16u);
 276         }
 277         else
 278         {
 279                 return tcu::UVec2(16u * 3u, 16u * 2u);
 280         }
 281 }
 282
 283 std::vector<Vertex4Tex4> SamplerTest::createVertices (void) const
 284 {
 285         std::vector<Vertex4Tex4> vertices = createTestQuadMosaic(m_imageViewType);
 286         // Adjust texture coordinate to avoid doing NEAREST filtering exactly on texel boundaries.
 287         // TODO: Would be nice to base this on number of texels and subtexel precision. But this
 288         // seems to work.
 289         for (unsigned int i = 0; i < vertices.size(); ++i) {
 290                 vertices[i].texCoord += tcu::Vec4(0.002f, 0.002f, 0.002f, 0.0f);
 291         }
 292         return vertices;
 293 }
 294
 295 VkSamplerCreateInfo SamplerTest::getSamplerCreateInfo (void) const
 296 {
 297         const VkSamplerCreateInfo defaultSamplerParams =
 298         {
 299                 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,                                                                  // VkStructureType                      sType;
 300                 DE_NULL,                                                                                                                                // const void*                          pNext;
 301                 0u,                                                                                                                                             // VkSamplerCreateFlags         flags;
 302                 VK_FILTER_NEAREST,                                                                                                              // VkFilter                                     magFilter;
 303                 VK_FILTER_NEAREST,                                                                                                              // VkFilter                                     minFilter;
 304                 VK_SAMPLER_MIPMAP_MODE_NEAREST,                                                                                 // VkSamplerMipmapMode          mipmapMode;
 305                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                                  // VkSamplerAddressMode         addressModeU;
 306                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                                  // VkSamplerAddressMode         addressModeV;
 307                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                                  // VkSamplerAddressMode         addressModeW;
 308                 0.0f,                                                                                                                                   // float                                        mipLodBias;
 309                 VK_FALSE,                                                                                                                               // VkBool32                                     anisotropyEnable;
 310                 1.0f,                                                                                                                                   // float                                        maxAnisotropy;
 311                 false,                                                                                                                                  // VkBool32                                     compareEnable;
 312                 VK_COMPARE_OP_NEVER,                                                                                                    // VkCompareOp                          compareOp;
 313                 0.0f,                                                                                                                                   // float                                        minLod;
 314                 0.25f,                                                                                                                                  // float                                        maxLod;
 315                 getFormatBorderColor(BORDER_COLOR_TRANSPARENT_BLACK, m_imageFormat),    // VkBorderColor                        borderColor;
 316                 false                                                                                                                                   // VkBool32                                     unnormalizedCoordinates;
 317         };
 318
 319         return defaultSamplerParams;
 320 }
 321
 322 std::string SamplerTest::getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
 323 {
 324         std::ostringstream samplerType;
 325
 326         if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
 327                 samplerType << "u";
 328         else if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
 329                 samplerType << "i";
 330
 331         switch (type)
 332         {
 333                 case VK_IMAGE_VIEW_TYPE_1D:
 334                         samplerType << "sampler1D";
 335                         break;
 336
 337                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 338                         samplerType << "sampler1DArray";
 339                         break;
 340
 341                 case VK_IMAGE_VIEW_TYPE_2D:
 342                         samplerType << "sampler2D";
 343                         break;
 344
 345                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 346                         samplerType << "sampler2DArray";
 347                         break;
 348
 349                 case VK_IMAGE_VIEW_TYPE_3D:
 350                         samplerType << "sampler3D";
 351                         break;
 352
 353                 case VK_IMAGE_VIEW_TYPE_CUBE:
 354                         samplerType << "samplerCube";
 355                         break;
 356
 357                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 358                         samplerType << "samplerCubeArray";
 359                         break;
 360
 361                 default:
 362                         DE_FATAL("Unknown image view type");
 363                         break;
 364         }
 365
 366         return samplerType.str();
 367 }
 368
 369 tcu::IVec3 SamplerTest::getImageSize (VkImageViewType viewType, int size)
 370 {
 371         switch (viewType)
 372         {
 373                 case VK_IMAGE_VIEW_TYPE_1D:
 374                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 375                         return tcu::IVec3(size, 1, 1);
 376
 377                 case VK_IMAGE_VIEW_TYPE_3D:
 378                         return tcu::IVec3(size, size, 4);
 379
 380                 default:
 381                         break;
 382         }
 383
 384         return tcu::IVec3(size, size, 1);
 385 }
 386
 387 int SamplerTest::getArraySize (VkImageViewType viewType)
 388 {
 389         switch (viewType)
 390         {
 391                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 392                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 393                 case VK_IMAGE_VIEW_TYPE_CUBE:
 394                         return 6;
 395
 396                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 397                         return 36;
 398
 399                 default:
 400                         break;
 401         }
 402
 403         return 1;
 404 }
 405
 406
 407 // SamplerMagFilterTest
 408
 409 SamplerMagFilterTest::SamplerMagFilterTest (tcu::TestContext&   testContext,
 410                                                                                         const char*                     name,
 411                                                                                         const char*                     description,
 412                                                                                         VkImageViewType         imageViewType,
 413                                                                                         VkFormat                        imageFormat,
 414                                                                                         VkFilter                        magFilter)
 415         : SamplerTest   (testContext, name, description, imageViewType, imageFormat, 8, 0.0f)
 416         , m_magFilter   (magFilter)
 417 {
 418 }
 419
 420 VkSamplerCreateInfo SamplerMagFilterTest::getSamplerCreateInfo (void) const
 421 {
 422         VkSamplerCreateInfo samplerParams = SamplerTest::getSamplerCreateInfo();
 423         samplerParams.magFilter = m_magFilter;
 424
 425         return samplerParams;
 426 }
 427
 428
 429 // SamplerMinFilterTest
 430
 431 SamplerMinFilterTest::SamplerMinFilterTest (tcu::TestContext&   testContext,
 432                                                                                         const char*                     name,
 433                                                                                         const char*                     description,
 434                                                                                         VkImageViewType         imageViewType,
 435                                                                                         VkFormat                        imageFormat,
 436                                                                                         VkFilter                        minFilter)
 437         : SamplerTest   (testContext, name, description, imageViewType, imageFormat, 32, 0.0f)
 438         , m_minFilter   (minFilter)
 439 {
 440 }
 441
 442 VkSamplerCreateInfo SamplerMinFilterTest::getSamplerCreateInfo (void) const
 443 {
 444         VkSamplerCreateInfo samplerParams = SamplerTest::getSamplerCreateInfo();
 445         samplerParams.minFilter = m_minFilter;
 446         // set minLod to epsilon, to force use of the minFilter
 447         samplerParams.minLod = 0.01f;
 448
 449         return samplerParams;
 450 }
 451
 452
 453 // SamplerLodTest
 454
 455 SamplerLodTest::SamplerLodTest (tcu::TestContext&       testContext,
 456                                                                 const char*                     name,
 457                                                                 const char*                     description,
 458                                                                 VkImageViewType         imageViewType,
 459                                                                 VkFormat                        imageFormat,
 460                                                                 VkSamplerMipmapMode     mipmapMode,
 461                                                                 float                           minLod,
 462                                                                 float                           maxLod,
 463                                                                 float                           mipLodBias,
 464                                                                 float                           samplerLod)
 465         : SamplerTest   (testContext, name, description, imageViewType, imageFormat, 32, samplerLod)
 466         , m_mipmapMode  (mipmapMode)
 467         , m_minLod              (minLod)
 468         , m_maxLod              (maxLod)
 469         , m_mipLodBias  (mipLodBias)
 470 {
 471 }
 472
 473 VkSamplerCreateInfo SamplerLodTest::getSamplerCreateInfo (void) const
 474 {
 475         VkSamplerCreateInfo samplerParams = SamplerTest::getSamplerCreateInfo();
 476
 477         samplerParams.mipmapMode        = m_mipmapMode;
 478         samplerParams.minLod            = m_minLod;
 479         samplerParams.maxLod            = m_maxLod;
 480         samplerParams.mipLodBias        = m_mipLodBias;
 481
 482         return samplerParams;
 483 }
 484
 485
 486 // SamplerAddressModesTest
 487
 488 SamplerAddressModesTest::SamplerAddressModesTest (tcu::TestContext&             testContext,
 489                                                                                                   const char*                   name,
 490                                                                                                   const char*                   description,
 491                                                                                                   VkImageViewType               imageViewType,
 492                                                                                                   VkFormat                              imageFormat,
 493                                                                                                   VkSamplerAddressMode  addressU,
 494                                                                                                   VkSamplerAddressMode  addressV,
 495                                                                                                   VkSamplerAddressMode  addressW,
 496                                                                                                   VkBorderColor                 borderColor)
 497         : SamplerTest   (testContext, name, description, imageViewType, imageFormat, 8, 0.0f)
 498         , m_addressU    (addressU)
 499         , m_addressV    (addressV)
 500         , m_addressW    (addressW)
 501         , m_borderColor (borderColor)
 502 {
 503 }
 504
 505 tcu::UVec2 SamplerAddressModesTest::getRenderSize (VkImageViewType viewType) const
 506 {
 507         return 4u * SamplerTest::getRenderSize(viewType);
 508 }
 509
 510 std::vector<Vertex4Tex4> SamplerAddressModesTest::createVertices (void) const
 511 {
 512         std::vector<Vertex4Tex4> vertices = SamplerTest::createVertices();
 513
 514         switch (m_imageViewType)
 515         {
 516                 case VK_IMAGE_VIEW_TYPE_1D: case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
 517                         for (size_t vertexNdx = 0; vertexNdx < vertices.size(); vertexNdx++)
 518                                 vertices[vertexNdx].texCoord.x() = (vertices[vertexNdx].texCoord.x() - 0.5f) * 4.0f;
 519
 520                         break;
 521
 522                 case VK_IMAGE_VIEW_TYPE_2D:
 523                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
 524                         for (size_t vertexNdx = 0; vertexNdx < vertices.size(); vertexNdx++)
 525                                 vertices[vertexNdx].texCoord.xy() = (vertices[vertexNdx].texCoord.swizzle(0, 1) - tcu::Vec2(0.5f)) * 4.0f;
 526
 527                         break;
 528
 529                 case VK_IMAGE_VIEW_TYPE_3D:
 530                         for (size_t vertexNdx = 0; vertexNdx < vertices.size(); vertexNdx++)
 531                                 vertices[vertexNdx].texCoord.xyz() = (vertices[vertexNdx].texCoord.swizzle(0, 1, 2) - tcu::Vec3(0.5f)) * 4.0f;
 532
 533                         break;
 534
 535                 case VK_IMAGE_VIEW_TYPE_CUBE:
 536                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
 537                         break;
 538
 539                 default:
 540                         DE_ASSERT(false);
 541         }
 542
 543         return vertices;
 544 }
 545
 546 VkSamplerCreateInfo SamplerAddressModesTest::getSamplerCreateInfo (void) const
 547 {
 548         VkSamplerCreateInfo samplerParams = SamplerTest::getSamplerCreateInfo();
 549         samplerParams.addressModeU      = m_addressU;
 550         samplerParams.addressModeV      = m_addressV;
 551         samplerParams.addressModeW      = m_addressW;
 552         samplerParams.borderColor       = m_borderColor;
 553
 554         return samplerParams;
 555 }
 556
 557
 558 // Utilities to create test nodes
 559
 560 std::string getFormatCaseName (const VkFormat format)
 561 {
 562         const std::string fullName = getFormatName(format);
 563
 564         DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
 565
 566         return de::toLower(fullName.substr(10));
 567 }
 568
 569 MovePtr<tcu::TestCaseGroup> createSamplerMagFilterTests (tcu::TestContext& testCtx, VkImageViewType imageViewType, VkFormat imageFormat)
 570 {
 571         MovePtr<tcu::TestCaseGroup> samplerMagFilterTests (new tcu::TestCaseGroup(testCtx, "mag_filter", "Tests for magnification filter"));
 572
 573         if (isCompressedFormat(imageFormat) || (!isIntFormat(imageFormat) && !isUintFormat(imageFormat)))
 574                 samplerMagFilterTests->addChild(new SamplerMagFilterTest(testCtx, "linear", "Magnifies image using VK_TEX_FILTER_LINEAR", imageViewType, imageFormat, VK_FILTER_LINEAR));
 575         samplerMagFilterTests->addChild(new SamplerMagFilterTest(testCtx, "nearest", "Magnifies image using VK_TEX_FILTER_NEAREST", imageViewType, imageFormat, VK_FILTER_NEAREST));
 576
 577         return samplerMagFilterTests;
 578 }
 579
 580 MovePtr<tcu::TestCaseGroup> createSamplerMinFilterTests (tcu::TestContext& testCtx, VkImageViewType imageViewType, VkFormat imageFormat)
 581 {
 582         MovePtr<tcu::TestCaseGroup> samplerMinFilterTests (new tcu::TestCaseGroup(testCtx, "min_filter", "Tests for minification filter"));
 583
 584         if (isCompressedFormat(imageFormat) || (!isIntFormat(imageFormat) && !isUintFormat(imageFormat)))
 585                 samplerMinFilterTests->addChild(new SamplerMinFilterTest(testCtx, "linear", "Minifies image using VK_TEX_FILTER_LINEAR", imageViewType, imageFormat, VK_FILTER_LINEAR));
 586         samplerMinFilterTests->addChild(new SamplerMinFilterTest(testCtx, "nearest", "Minifies image using VK_TEX_FILTER_NEAREST", imageViewType, imageFormat, VK_FILTER_NEAREST));
 587
 588         return samplerMinFilterTests;
 589 }
 590
 591 MovePtr<tcu::TestCaseGroup> createSamplerLodTests (tcu::TestContext& testCtx, VkImageViewType imageViewType, VkFormat imageFormat, VkSamplerMipmapMode mipmapMode)
 592 {
 593         struct TestCaseConfig
 594         {
 595                 const char*     name;
 596                 const char*     description;
 597                 float           minLod;
 598                 float           maxLod;
 599                 float           mipLodBias;
 600                 float           lod;
 601         };
 602
 603         TestCaseConfig testCaseConfigs [] =
 604         {
 605                 { "equal_min_3_max_3",          "minLod = 3, maxLod = 3, mipLodBias = 0, lod = 0",              3.0f, 3.0f, 0.0f, 0.0f },
 606                 { "select_min_1",                       "minLod = 1, maxLod = 5, mipLodBias = 0, lod = 0",              1.0f, 5.0f, 0.0f, 0.0f },
 607                 { "select_max_4",                       "minLod = 0, maxLod = 4, mipLodBias = 0, lod = 5",              0.0f, 4.0f, 0.0f, 5.0f },
 608                 { "select_bias_2_1",            "minLod = 0, maxLod = 2.1, mipLodBias = 5.0, lod = 0",  0.0f, 2.1f, 5.0f, 0.0f },
 609                 { "select_bias_2_5",            "minLod = 0, maxLod = 5, mipLodBias = 2.5, lod = 0",    0.0f, 5.0f, 2.5f, 0.00001f },
 610                 { "select_bias_3_1",            "minLod = 0, maxLod = 5, mipLodBias = -0.9, lod = 4.0", 0.0f, 5.0f, -0.9f, 4.0f },
 611                 { "select_bias_3_7",            "minLod = 0, maxLod = 5, mipLodBias = 3.0, lod = 0.7",  0.0f, 5.0f, 3.0f, 0.7f },
 612         };
 613
 614         MovePtr<tcu::TestCaseGroup> samplerLodTests (new tcu::TestCaseGroup(testCtx, "lod", "Tests for sampler LOD"));
 615
 616         for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(testCaseConfigs); configNdx++)
 617         {
 618                 const TestCaseConfig& config = testCaseConfigs[configNdx];
 619
 620                 samplerLodTests->addChild(new SamplerLodTest(testCtx, config.name, config.description, imageViewType, imageFormat, mipmapMode, config.minLod, config.maxLod, config.mipLodBias, config.lod));
 621         }
 622
 623         return samplerLodTests;
 624 }
 625
 626 MovePtr<tcu::TestCaseGroup> createSamplerMipmapTests (tcu::TestContext& testCtx, VkImageViewType imageViewType, VkFormat imageFormat)
 627 {
 628         MovePtr<tcu::TestCaseGroup> samplerMipmapTests (new tcu::TestCaseGroup(testCtx, "mipmap", "Tests for mipmap modes"));
 629
 630         // Mipmap mode: nearest
 631         MovePtr<tcu::TestCaseGroup> mipmapNearestTests (new tcu::TestCaseGroup(testCtx, "nearest", "Uses VK_TEX_MIPMAP_MODE_NEAREST"));
 632         mipmapNearestTests->addChild(createSamplerLodTests(testCtx, imageViewType, imageFormat, VK_SAMPLER_MIPMAP_MODE_NEAREST).release());
 633         samplerMipmapTests->addChild(mipmapNearestTests.release());
 634
 635         // Mipmap mode: linear
 636         if (isCompressedFormat(imageFormat) || (!isIntFormat(imageFormat) && !isUintFormat(imageFormat)))
 637         {
 638                 MovePtr<tcu::TestCaseGroup> mipmapLinearTests(new tcu::TestCaseGroup(testCtx, "linear", "Uses VK_TEX_MIPMAP_MODE_LINEAR"));
 639                 mipmapLinearTests->addChild(createSamplerLodTests(testCtx, imageViewType, imageFormat, VK_SAMPLER_MIPMAP_MODE_LINEAR).release());
 640                 samplerMipmapTests->addChild(mipmapLinearTests.release());
 641         }
 642
 643         return samplerMipmapTests;
 644 }
 645
 646 std::string getAddressModesCaseName (VkSamplerAddressMode u, VkSamplerAddressMode v, VkSamplerAddressMode w, BorderColor border)
 647 {
 648         static const char* borderColorNames[BORDER_COLOR_COUNT] =
 649         {
 650                 "opaque_black",
 651                 "opaque_white",
 652                 "transparent_black",
 653         };
 654
 655         std::ostringstream caseName;
 656
 657         if (u == v && v == w)
 658         {
 659                 const std::string fullName = getSamplerAddressModeName(u);
 660                 DE_ASSERT(de::beginsWith(fullName, "VK_SAMPLER_ADDRESS_"));
 661
 662                 caseName << "all_";
 663                 caseName << de::toLower(fullName.substr(19));
 664
 665                 if (u == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)
 666                 {
 667                         caseName << "_" << borderColorNames[border];
 668                 }
 669         }
 670         else
 671         {
 672                 const std::string fullNameU = getSamplerAddressModeName(u);
 673                 const std::string fullNameV = getSamplerAddressModeName(v);
 674                 const std::string fullNameW = getSamplerAddressModeName(w);
 675
 676                 DE_ASSERT(de::beginsWith(fullNameU, "VK_SAMPLER_ADDRESS_"));
 677                 DE_ASSERT(de::beginsWith(fullNameV, "VK_SAMPLER_ADDRESS_"));
 678                 DE_ASSERT(de::beginsWith(fullNameW, "VK_SAMPLER_ADDRESS_"));
 679
 680                 caseName << "uvw"
 681                                  << "_" << de::toLower(fullNameU.substr(19))
 682                                  << "_" << de::toLower(fullNameV.substr(19))
 683                                  << "_" << de::toLower(fullNameW.substr(19));
 684         }
 685
 686         return caseName.str();
 687 }
 688
 689 MovePtr<tcu::TestCaseGroup> createSamplerAddressModesTests (tcu::TestContext& testCtx, VkImageViewType imageViewType, VkFormat imageFormat)
 690 {
 691         struct TestCaseConfig
 692         {
 693                 VkSamplerAddressMode    u;
 694                 VkSamplerAddressMode    v;
 695                 VkSamplerAddressMode    w;
 696                 BorderColor                             border;
 697         };
 698
 699         const TestCaseConfig testCaseConfigs[] =
 700         {
 701                 // All address modes equal
 702                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  BORDER_COLOR_TRANSPARENT_BLACK },
 703                 { VK_SAMPLER_ADDRESS_MODE_REPEAT,                               VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 BORDER_COLOR_TRANSPARENT_BLACK },
 704                 { VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,              VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                BORDER_COLOR_TRANSPARENT_BLACK },
 705                 { VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   BORDER_COLOR_TRANSPARENT_BLACK },
 706
 707                 // All address modes equal using border color
 708                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,              VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                BORDER_COLOR_TRANSPARENT_BLACK },
 709                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,              VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                BORDER_COLOR_OPAQUE_BLACK },
 710                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,              VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                BORDER_COLOR_OPAQUE_WHITE },
 711
 712                 // Pairwise combinations of address modes not covered by previous tests
 713                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,              VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 BORDER_COLOR_OPAQUE_WHITE},
 714                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,              VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   BORDER_COLOR_OPAQUE_WHITE },
 715                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,              VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                BORDER_COLOR_OPAQUE_WHITE },
 716                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,              VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  BORDER_COLOR_OPAQUE_WHITE },
 717                 { VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                BORDER_COLOR_OPAQUE_WHITE },
 718                 { VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                BORDER_COLOR_OPAQUE_WHITE },
 719                 { VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 BORDER_COLOR_OPAQUE_WHITE },
 720                 { VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   BORDER_COLOR_OPAQUE_WHITE },
 721                 { VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  BORDER_COLOR_OPAQUE_WHITE },
 722                 { VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,              VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   BORDER_COLOR_OPAQUE_WHITE },
 723                 { VK_SAMPLER_ADDRESS_MODE_REPEAT,                               VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   BORDER_COLOR_OPAQUE_WHITE },
 724                 { VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,              VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                BORDER_COLOR_OPAQUE_WHITE },
 725                 { VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,              VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 BORDER_COLOR_OPAQUE_WHITE },
 726                 { VK_SAMPLER_ADDRESS_MODE_REPEAT,                               VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  BORDER_COLOR_OPAQUE_WHITE },
 727                 { VK_SAMPLER_ADDRESS_MODE_REPEAT,                               VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                BORDER_COLOR_OPAQUE_WHITE },
 728                 { VK_SAMPLER_ADDRESS_MODE_REPEAT,                               VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                BORDER_COLOR_OPAQUE_WHITE },
 729                 { VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,              VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  BORDER_COLOR_OPAQUE_WHITE },
 730                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                BORDER_COLOR_OPAQUE_WHITE },
 731                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,                VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 BORDER_COLOR_OPAQUE_WHITE },
 732                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                VK_SAMPLER_ADDRESS_MODE_REPEAT,                                 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   BORDER_COLOR_OPAQUE_WHITE },
 733                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                  BORDER_COLOR_OPAQUE_WHITE },
 734                 { VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,   VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,                BORDER_COLOR_OPAQUE_WHITE },
 735         };
 736
 737         MovePtr<tcu::TestCaseGroup> samplerAddressModesTests (new tcu::TestCaseGroup(testCtx, "address_modes", "Tests for address modes"));
 738
 739         for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(testCaseConfigs); configNdx++)
 740         {
 741                 const TestCaseConfig& config = testCaseConfigs[configNdx];
 742
 743                 samplerAddressModesTests->addChild(new SamplerAddressModesTest(testCtx,
 744                                                                                                                                            getAddressModesCaseName(config.u, config.v, config.w, config.border).c_str(),
 745                                                                                                                                            "",
 746                                                                                                                                            imageViewType,
 747                                                                                                                                            imageFormat,
 748                                                                                                                                            config.u, config.v, config.w,
 749                                                                                                                                            getFormatBorderColor(config.border, imageFormat)));
 750         }
 751
 752         return samplerAddressModesTests;
 753 }
 754
 755 } // anonymous
 756
 757 tcu::TestCaseGroup* createSamplerTests (tcu::TestContext& testCtx)
 758 {
 759         const struct
 760         {
 761                 VkImageViewType         type;
 762                 const char*                     name;
 763         }
 764         imageViewTypes[] =
 765         {
 766                 { VK_IMAGE_VIEW_TYPE_1D,                        "1d" },
 767                 { VK_IMAGE_VIEW_TYPE_1D_ARRAY,          "1d_array" },
 768                 { VK_IMAGE_VIEW_TYPE_2D,                        "2d" },
 769                 { VK_IMAGE_VIEW_TYPE_2D_ARRAY,          "2d_array" },
 770                 { VK_IMAGE_VIEW_TYPE_3D,                        "3d" },
 771                 { VK_IMAGE_VIEW_TYPE_CUBE,                      "cube" },
 772                 { VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,        "cube_array" }
 773         };
 774
 775         const VkFormat formats[] =
 776         {
 777                 // Packed formats
 778                 VK_FORMAT_R4G4_UNORM_PACK8,
 779                 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
 780                 VK_FORMAT_R5G6B5_UNORM_PACK16,
 781                 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
 782                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
 783                 VK_FORMAT_A2R10G10B10_UINT_PACK32,
 784                 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
 785                 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
 786                 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
 787                 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
 788
 789                 // Pairwise combinations of 8-bit channel formats, UNORM/SNORM/SINT/UINT/SRGB type x 1-to-4 channels x RGBA/BGRA order
 790                 VK_FORMAT_R8_SRGB,
 791                 VK_FORMAT_R8G8B8_UINT,
 792                 VK_FORMAT_B8G8R8A8_SINT,
 793                 VK_FORMAT_R8G8_UNORM,
 794                 VK_FORMAT_B8G8R8_SNORM,
 795                 VK_FORMAT_R8G8B8A8_SNORM,
 796                 VK_FORMAT_R8G8_UINT,
 797                 VK_FORMAT_R8_SINT,
 798                 VK_FORMAT_R8G8B8A8_SRGB,
 799                 VK_FORMAT_R8G8B8A8_UNORM,
 800                 VK_FORMAT_B8G8R8A8_UNORM,
 801                 VK_FORMAT_B8G8R8_SRGB,
 802                 VK_FORMAT_R8G8_SRGB,
 803                 VK_FORMAT_R8_UINT,
 804                 VK_FORMAT_R8G8B8A8_UINT,
 805                 VK_FORMAT_R8G8_SINT,
 806                 VK_FORMAT_R8_SNORM,
 807                 VK_FORMAT_B8G8R8_SINT,
 808                 VK_FORMAT_R8G8_SNORM,
 809                 VK_FORMAT_B8G8R8_UNORM,
 810                 VK_FORMAT_R8_UNORM,
 811
 812                 // Pairwise combinations of 16/32-bit channel formats x SINT/UINT/SFLOAT type x 1-to-4 channels
 813                 VK_FORMAT_R32G32_SFLOAT,
 814                 VK_FORMAT_R32G32B32_UINT,
 815                 VK_FORMAT_R16G16B16A16_SFLOAT,
 816                 VK_FORMAT_R16G16_UINT,
 817                 VK_FORMAT_R32G32B32A32_SINT,
 818                 VK_FORMAT_R16G16B16_SINT,
 819                 VK_FORMAT_R16_SFLOAT,
 820                 VK_FORMAT_R32_SINT,
 821                 VK_FORMAT_R32_UINT,
 822                 VK_FORMAT_R16G16B16_SFLOAT,
 823                 VK_FORMAT_R16G16_SINT,
 824
 825                 // Scaled formats
 826                 VK_FORMAT_R8G8B8A8_SSCALED,
 827                 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
 828
 829                 // Compressed formats
 830                 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
 831                 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
 832                 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
 833                 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
 834                 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
 835                 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
 836                 VK_FORMAT_EAC_R11_UNORM_BLOCK,
 837                 VK_FORMAT_EAC_R11_SNORM_BLOCK,
 838                 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
 839                 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
 840                 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
 841                 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
 842                 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
 843                 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
 844                 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
 845                 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
 846                 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
 847                 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
 848                 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
 849                 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
 850         };
 851
 852         de::MovePtr<tcu::TestCaseGroup> samplerTests            (new tcu::TestCaseGroup(testCtx, "sampler", "Sampler tests"));
 853         de::MovePtr<tcu::TestCaseGroup> viewTypeTests           (new tcu::TestCaseGroup(testCtx, "view_type", ""));
 854
 855         for (int viewTypeNdx = 0; viewTypeNdx < DE_LENGTH_OF_ARRAY(imageViewTypes); viewTypeNdx++)
 856         {
 857                 const VkImageViewType                   viewType                = imageViewTypes[viewTypeNdx].type;
 858                 de::MovePtr<tcu::TestCaseGroup> viewTypeGroup   (new tcu::TestCaseGroup(testCtx, imageViewTypes[viewTypeNdx].name, (std::string("Uses a ") + imageViewTypes[viewTypeNdx].name + " view").c_str()));
 859                 de::MovePtr<tcu::TestCaseGroup> formatTests             (new tcu::TestCaseGroup(testCtx, "format", "Tests samplable formats"));
 860
 861                 for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
 862                 {
 863                         const VkFormat  format                  = formats[formatNdx];
 864                         const bool              isCompressed    = isCompressedFormat(format);
 865
 866                         if (isCompressed)
 867                         {
 868                                 // Do not use compressed formats with 1D and 1D array textures.
 869                                 if (viewType == VK_IMAGE_VIEW_TYPE_1D || viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY)
 870                                         break;
 871                         }
 872
 873                         de::MovePtr<tcu::TestCaseGroup> formatGroup     (new tcu::TestCaseGroup(testCtx,
 874                                                                                                                                                                 getFormatCaseName(format).c_str(),
 875                                                                                                                                                                 (std::string("Samples a texture of format ") + getFormatName(format)).c_str()));
 876
 877                         if (!isCompressed)
 878                         {
 879                                 // Do not include minFilter tests with compressed formats.
 880                                 // Randomly generated compressed textures are too noisy and will derive in false positives.
 881                                 de::MovePtr<tcu::TestCaseGroup> minFilterTests          = createSamplerMinFilterTests(testCtx, viewType, format);
 882                                 formatGroup->addChild(minFilterTests.release());
 883                         }
 884
 885                         de::MovePtr<tcu::TestCaseGroup> magFilterTests          = createSamplerMagFilterTests(testCtx, viewType, format);
 886                         de::MovePtr<tcu::TestCaseGroup> mipmapTests                     = createSamplerMipmapTests(testCtx, viewType, format);
 887
 888                         formatGroup->addChild(magFilterTests.release());
 889                         formatGroup->addChild(mipmapTests.release());
 890
 891                         if (viewType != VK_IMAGE_VIEW_TYPE_CUBE && viewType != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
 892                         {
 893                                 de::MovePtr<tcu::TestCaseGroup> addressModesTests       = createSamplerAddressModesTests(testCtx, viewType, format);
 894                                 formatGroup->addChild(addressModesTests.release());
 895                         }
 896
 897                         formatTests->addChild(formatGroup.release());
 898                 }
 899
 900                 viewTypeGroup->addChild(formatTests.release());
 901                 viewTypeTests->addChild(viewTypeGroup.release());
 902         }
 903
 904         samplerTests->addChild(viewTypeTests.release());
 905
 906         return samplerTests.release();
 907 }
 908
 909 } // pipeline
 910 } // vkt