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