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 Image Tests 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktPipelineImageTests.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 "tcuTextureUtil.hpp" 33 #include "deStringUtil.hpp" 34 35 #include <sstream> 36 #include <vector> 37 38 namespace vkt 39 { 40 namespace pipeline 41 { 42 43 using namespace vk; 44 using de::MovePtr; 45 46 namespace 47 { 48 49 class ImageTest : public vkt::TestCase 50 { 51 public: 52 ImageTest (tcu::TestContext& testContext, 53 const char* name, 54 const char* description, 55 56 AllocationKind allocationKind, 57 VkDescriptorType samplingType, 58 VkImageViewType imageViewType, 59 VkFormat imageFormat, 60 const tcu::IVec3& imageSize, 61 int imageCount, 62 int arraySize); 63 64 virtual void initPrograms (SourceCollections& sourceCollections) const; 65 virtual TestInstance* createInstance (Context& context) const; 66 static std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type); 67 static std::string getGlslTextureType (const tcu::TextureFormat& format, VkImageViewType type); 68 static std::string getGlslSamplerDecl (int imageCount); 69 static std::string getGlslTextureDecl (int imageCount); 70 static std::string getGlslFragColorDecl (int imageCount); 71 static std::string getGlslSampler (const tcu::TextureFormat& format, 72 VkImageViewType type, 73 VkDescriptorType samplingType, 74 int imageCount); 75 76 private: 77 AllocationKind m_allocationKind; 78 VkDescriptorType m_samplingType; 79 VkImageViewType m_imageViewType; 80 VkFormat m_imageFormat; 81 tcu::IVec3 m_imageSize; 82 int m_imageCount; 83 int m_arraySize; 84 }; 85 86 ImageTest::ImageTest (tcu::TestContext& testContext, 87 const char* name, 88 const char* description, 89 AllocationKind allocationKind, 90 VkDescriptorType samplingType, 91 VkImageViewType imageViewType, 92 VkFormat imageFormat, 93 const tcu::IVec3& imageSize, 94 int imageCount, 95 int arraySize) 96 97 : vkt::TestCase (testContext, name, description) 98 , m_allocationKind (allocationKind) 99 , m_samplingType (samplingType) 100 , m_imageViewType (imageViewType) 101 , m_imageFormat (imageFormat) 102 , m_imageSize (imageSize) 103 , m_imageCount (imageCount) 104 , m_arraySize (arraySize) 105 { 106 } 107 108 void ImageTest::initPrograms (SourceCollections& sourceCollections) const 109 { 110 std::ostringstream vertexSrc; 111 std::ostringstream fragmentSrc; 112 const char* texCoordSwizzle = DE_NULL; 113 const tcu::TextureFormat format = (isCompressedFormat(m_imageFormat)) ? tcu::getUncompressedFormat(mapVkCompressedFormat(m_imageFormat)) 114 : mapVkFormat(m_imageFormat); 115 116 tcu::Vec4 lookupScale; 117 tcu::Vec4 lookupBias; 118 119 getLookupScaleBias(m_imageFormat, lookupScale, lookupBias); 120 121 switch (m_imageViewType) 122 { 123 case VK_IMAGE_VIEW_TYPE_1D: 124 texCoordSwizzle = "x"; 125 break; 126 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: 127 case VK_IMAGE_VIEW_TYPE_2D: 128 texCoordSwizzle = "xy"; 129 break; 130 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: 131 case VK_IMAGE_VIEW_TYPE_3D: 132 case VK_IMAGE_VIEW_TYPE_CUBE: 133 texCoordSwizzle = "xyz"; 134 break; 135 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: 136 texCoordSwizzle = "xyzw"; 137 break; 138 default: 139 DE_ASSERT(false); 140 break; 141 } 142 143 vertexSrc << "#version 440\n" 144 << "layout(location = 0) in vec4 position;\n" 145 << "layout(location = 1) in vec4 texCoords;\n" 146 << "layout(location = 0) out highp vec4 vtxTexCoords;\n" 147 << "out gl_PerVertex {\n" 148 << " vec4 gl_Position;\n" 149 << "};\n" 150 << "void main (void)\n" 151 << "{\n" 152 << " gl_Position = position;\n" 153 << " vtxTexCoords = texCoords;\n" 154 << "}\n"; 155 156 fragmentSrc << "#version 440\n"; 157 switch (m_samplingType) 158 { 159 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: 160 fragmentSrc 161 << "layout(set = 0, binding = 0) uniform highp sampler texSampler;\n" 162 << "layout(set = 0, binding = 1) uniform highp " << getGlslTextureType(format, m_imageViewType) << " " << getGlslTextureDecl(m_imageCount) << ";\n"; 163 break; 164 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: 165 default: 166 fragmentSrc 167 << "layout(set = 0, binding = 0) uniform highp " << getGlslSamplerType(format, m_imageViewType) << " " << getGlslSamplerDecl(m_imageCount) << ";\n"; 168 } 169 fragmentSrc << "layout(location = 0) in highp vec4 vtxTexCoords;\n" 170 << "layout(location = 0) out highp vec4 " << getGlslFragColorDecl(m_imageCount) << ";\n" 171 << "void main (void)\n" 172 << "{\n"; 173 if (m_imageCount > 1) 174 fragmentSrc 175 << " for (uint i = 0; i < " << m_imageCount << "; ++i)\n" 176 << " fragColors[i] = (texture(" << getGlslSampler(format, m_imageViewType, m_samplingType, m_imageCount) << ", vtxTexCoords." << texCoordSwizzle << std::scientific << ") * vec4" << lookupScale << ") + vec4" << lookupBias << "; \n"; 177 else 178 fragmentSrc 179 << " fragColor = (texture(" << getGlslSampler(format, m_imageViewType, m_samplingType, m_imageCount) << ", vtxTexCoords." << texCoordSwizzle << std::scientific << ") * vec4" << lookupScale << ") + vec4" << lookupBias << "; \n"; 180 fragmentSrc << "}\n"; 181 182 sourceCollections.glslSources.add("tex_vert") << glu::VertexSource(vertexSrc.str()); 183 sourceCollections.glslSources.add("tex_frag") << glu::FragmentSource(fragmentSrc.str()); 184 } 185 186 TestInstance* ImageTest::createInstance (Context& context) const 187 { 188 tcu::UVec2 renderSize; 189 const VkPhysicalDeviceFeatures& features = context.getDeviceFeatures(); 190 191 // Using an loop to index into an array of images requires shaderSampledImageArrayDynamicIndexing 192 if (m_imageCount > 1 && features.shaderSampledImageArrayDynamicIndexing == VK_FALSE) 193 { 194 TCU_THROW(NotSupportedError, "shaderSampledImageArrayDynamicIndexing feature is not supported"); 195 } 196 197 if (m_imageViewType == VK_IMAGE_VIEW_TYPE_1D || m_imageViewType == VK_IMAGE_VIEW_TYPE_2D) 198 { 199 renderSize = tcu::UVec2((deUint32)m_imageSize.x(), (deUint32)m_imageSize.y()); 200 } 201 else 202 { 203 // Draw a 3x2 grid of texture layers 204 renderSize = tcu::UVec2((deUint32)m_imageSize.x() * 3, (deUint32)m_imageSize.y() * 2); 205 } 206 207 const std::vector<Vertex4Tex4> vertices = createTestQuadMosaic(m_imageViewType); 208 const VkComponentMapping componentMapping = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A }; 209 const VkImageSubresourceRange subresourceRange = 210 { 211 VK_IMAGE_ASPECT_COLOR_BIT, 212 0u, 213 (deUint32)deLog2Floor32(deMax32(m_imageSize.x(), deMax32(m_imageSize.y(), m_imageSize.z()))) + 1, 214 0u, 215 (deUint32)m_arraySize, 216 }; 217 218 const VkSamplerCreateInfo samplerParams = 219 { 220 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType; 221 DE_NULL, // const void* pNext; 222 0u, // VkSamplerCreateFlags flags; 223 VK_FILTER_NEAREST, // VkFilter magFilter; 224 VK_FILTER_NEAREST, // VkFilter minFilter; 225 VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode; 226 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU; 227 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV; 228 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW; 229 0.0f, // float mipLodBias; 230 VK_FALSE, // VkBool32 anisotropyEnable; 231 1.0f, // float maxAnisotropy; 232 false, // VkBool32 compareEnable; 233 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; 234 0.0f, // float minLod; 235 (float)(subresourceRange.levelCount - 1), // float maxLod; 236 getFormatBorderColor(BORDER_COLOR_TRANSPARENT_BLACK, m_imageFormat), // VkBorderColor borderColor; 237 false // VkBool32 unnormalizedCoordinates; 238 }; 239 240 return new ImageSamplingInstance(context, renderSize, m_imageViewType, m_imageFormat, m_imageSize, m_arraySize, componentMapping, subresourceRange, samplerParams, 0.0f, vertices, m_samplingType, m_imageCount, m_allocationKind); 241 } 242 243 std::string ImageTest::getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type) 244 { 245 std::ostringstream samplerType; 246 247 if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) 248 samplerType << "u"; 249 else if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) 250 samplerType << "i"; 251 252 switch (type) 253 { 254 case VK_IMAGE_VIEW_TYPE_1D: 255 samplerType << "sampler1D"; 256 break; 257 258 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: 259 samplerType << "sampler1DArray"; 260 break; 261 262 case VK_IMAGE_VIEW_TYPE_2D: 263 samplerType << "sampler2D"; 264 break; 265 266 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: 267 samplerType << "sampler2DArray"; 268 break; 269 270 case VK_IMAGE_VIEW_TYPE_3D: 271 samplerType << "sampler3D"; 272 break; 273 274 case VK_IMAGE_VIEW_TYPE_CUBE: 275 samplerType << "samplerCube"; 276 break; 277 278 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: 279 samplerType << "samplerCubeArray"; 280 break; 281 282 default: 283 DE_FATAL("Unknown image view type"); 284 break; 285 } 286 287 return samplerType.str(); 288 } 289 290 std::string ImageTest::getGlslTextureType (const tcu::TextureFormat& format, VkImageViewType type) 291 { 292 std::ostringstream textureType; 293 294 if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) 295 textureType << "u"; 296 else if (tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) 297 textureType << "i"; 298 299 switch (type) 300 { 301 case VK_IMAGE_VIEW_TYPE_1D: 302 textureType << "texture1D"; 303 break; 304 305 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: 306 textureType << "texture1DArray"; 307 break; 308 309 case VK_IMAGE_VIEW_TYPE_2D: 310 textureType << "texture2D"; 311 break; 312 313 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: 314 textureType << "texture2DArray"; 315 break; 316 317 case VK_IMAGE_VIEW_TYPE_3D: 318 textureType << "texture3D"; 319 break; 320 321 case VK_IMAGE_VIEW_TYPE_CUBE: 322 textureType << "textureCube"; 323 break; 324 325 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: 326 textureType << "textureCubeArray"; 327 break; 328 329 default: 330 DE_FATAL("Unknown image view type"); 331 } 332 333 return textureType.str(); 334 } 335 336 std::string ImageTest::getGlslSamplerDecl (int imageCount) 337 { 338 std::ostringstream samplerArray; 339 samplerArray << "texSamplers[" << imageCount << "]"; 340 341 return imageCount > 1 ? samplerArray.str() : "texSampler"; 342 } 343 344 std::string ImageTest::getGlslTextureDecl (int imageCount) 345 { 346 std::ostringstream textureArray; 347 textureArray << "texImages[" << imageCount << "]"; 348 349 return imageCount > 1 ? textureArray.str() : "texImage"; 350 } 351 352 std::string ImageTest::getGlslFragColorDecl (int imageCount) 353 { 354 std::ostringstream samplerArray; 355 samplerArray << "fragColors[" << imageCount << "]"; 356 357 return imageCount > 1 ? samplerArray.str() : "fragColor"; 358 } 359 360 std::string ImageTest::getGlslSampler (const tcu::TextureFormat& format, VkImageViewType type, VkDescriptorType samplingType, int imageCount) 361 { 362 std::string texSampler = imageCount > 1 ? "texSamplers[i]" : "texSampler"; 363 std::string texImage = imageCount > 1 ? "texImages[i]" : "texImage"; 364 365 switch (samplingType) 366 { 367 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: 368 return getGlslSamplerType(format, type) + "(" + texImage + ", texSampler)"; 369 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: 370 default: 371 return texSampler; 372 } 373 } 374 375 std::string getFormatCaseName (const VkFormat format) 376 { 377 const std::string fullName = getFormatName(format); 378 379 DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_")); 380 381 return de::toLower(fullName.substr(10)); 382 } 383 384 std::string getSizeName (VkImageViewType viewType, const tcu::IVec3& size, int arraySize) 385 { 386 std::ostringstream caseName; 387 388 switch (viewType) 389 { 390 case VK_IMAGE_VIEW_TYPE_1D: 391 case VK_IMAGE_VIEW_TYPE_2D: 392 case VK_IMAGE_VIEW_TYPE_CUBE: 393 caseName << size.x() << "x" << size.y(); 394 break; 395 396 case VK_IMAGE_VIEW_TYPE_3D: 397 caseName << size.x() << "x" << size.y() << "x" << size.z(); 398 break; 399 400 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: 401 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: 402 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: 403 caseName << size.x() << "x" << size.y() << "_array_of_" << arraySize; 404 break; 405 406 default: 407 DE_ASSERT(false); 408 break; 409 } 410 411 return caseName.str(); 412 } 413 414 de::MovePtr<tcu::TestCaseGroup> createImageSizeTests (tcu::TestContext& testCtx, AllocationKind allocationKind, VkDescriptorType samplingType, VkImageViewType imageViewType, VkFormat imageFormat, int imageCount) 415 { 416 using tcu::IVec3; 417 418 std::vector<IVec3> imageSizes; 419 std::vector<int> arraySizes; 420 de::MovePtr<tcu::TestCaseGroup> imageSizeTests (new tcu::TestCaseGroup(testCtx, "size", "")); 421 422 // Select image imageSizes 423 switch (imageViewType) 424 { 425 case VK_IMAGE_VIEW_TYPE_1D: 426 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: 427 // POT 428 if (imageCount == 1) 429 { 430 imageSizes.push_back(IVec3(1, 1, 1)); 431 imageSizes.push_back(IVec3(2, 1, 1)); 432 imageSizes.push_back(IVec3(32, 1, 1)); 433 imageSizes.push_back(IVec3(128, 1, 1)); 434 } 435 imageSizes.push_back(IVec3(512, 1, 1)); 436 437 // NPOT 438 if (imageCount == 1) 439 { 440 imageSizes.push_back(IVec3(3, 1, 1)); 441 imageSizes.push_back(IVec3(13, 1, 1)); 442 imageSizes.push_back(IVec3(127, 1, 1)); 443 } 444 imageSizes.push_back(IVec3(443, 1, 1)); 445 break; 446 447 case VK_IMAGE_VIEW_TYPE_2D: 448 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: 449 if (imageCount == 1) 450 { 451 // POT 452 imageSizes.push_back(IVec3(1, 1, 1)); 453 imageSizes.push_back(IVec3(2, 2, 1)); 454 imageSizes.push_back(IVec3(32, 32, 1)); 455 456 // NPOT 457 imageSizes.push_back(IVec3(3, 3, 1)); 458 imageSizes.push_back(IVec3(13, 13, 1)); 459 } 460 461 // POT rectangular 462 if (imageCount == 1) 463 imageSizes.push_back(IVec3(8, 16, 1)); 464 imageSizes.push_back(IVec3(32, 16, 1)); 465 466 // NPOT rectangular 467 imageSizes.push_back(IVec3(13, 23, 1)); 468 if (imageCount == 1) 469 imageSizes.push_back(IVec3(23, 8, 1)); 470 break; 471 472 case VK_IMAGE_VIEW_TYPE_3D: 473 // POT cube 474 if (imageCount == 1) 475 { 476 imageSizes.push_back(IVec3(1, 1, 1)); 477 imageSizes.push_back(IVec3(2, 2, 2)); 478 } 479 imageSizes.push_back(IVec3(16, 16, 16)); 480 481 // NPOT cube 482 if (imageCount == 1) 483 { 484 imageSizes.push_back(IVec3(3, 3, 3)); 485 imageSizes.push_back(IVec3(5, 5, 5)); 486 } 487 imageSizes.push_back(IVec3(11, 11, 11)); 488 489 // POT non-cube 490 if (imageCount == 1) 491 imageSizes.push_back(IVec3(32, 16, 8)); 492 imageSizes.push_back(IVec3(8, 16, 32)); 493 494 // NPOT non-cube 495 imageSizes.push_back(IVec3(17, 11, 5)); 496 if (imageCount == 1) 497 imageSizes.push_back(IVec3(5, 11, 17)); 498 break; 499 500 case VK_IMAGE_VIEW_TYPE_CUBE: 501 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: 502 // POT 503 imageSizes.push_back(IVec3(32, 32, 1)); 504 505 // NPOT 506 imageSizes.push_back(IVec3(13, 13, 1)); 507 break; 508 509 default: 510 DE_ASSERT(false); 511 break; 512 } 513 514 // Select array sizes 515 switch (imageViewType) 516 { 517 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: 518 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: 519 if (imageCount == 1) 520 arraySizes.push_back(3); 521 arraySizes.push_back(6); 522 break; 523 524 case VK_IMAGE_VIEW_TYPE_CUBE: 525 arraySizes.push_back(6); 526 break; 527 528 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: 529 if (imageCount == 1) 530 arraySizes.push_back(6); 531 arraySizes.push_back(6 * 6); 532 break; 533 534 default: 535 arraySizes.push_back(1); 536 break; 537 } 538 539 for (size_t sizeNdx = 0; sizeNdx < imageSizes.size(); sizeNdx++) 540 { 541 for (size_t arraySizeNdx = 0; arraySizeNdx < arraySizes.size(); arraySizeNdx++) 542 { 543 imageSizeTests->addChild(new ImageTest(testCtx, 544 getSizeName(imageViewType, imageSizes[sizeNdx], arraySizes[arraySizeNdx]).c_str(), 545 "", 546 allocationKind, 547 samplingType, 548 imageViewType, 549 imageFormat, 550 imageSizes[sizeNdx], 551 imageCount, 552 arraySizes[arraySizeNdx])); 553 } 554 } 555 556 return imageSizeTests; 557 } 558 559 void createImageCountTests (tcu::TestCaseGroup* parentGroup, tcu::TestContext& testCtx, AllocationKind allocationKind, VkDescriptorType samplingType, VkImageViewType imageViewType, VkFormat imageFormat) 560 { 561 const int coreImageCounts[] = { 1, 4, 8 }; 562 const int dedicatedAllocationImageCounts[] = { 1 }; 563 const int* imageCounts = (allocationKind == ALLOCATION_KIND_DEDICATED) 564 ? dedicatedAllocationImageCounts 565 : coreImageCounts; 566 const size_t imageCountsLength = (allocationKind == ALLOCATION_KIND_DEDICATED) 567 ? DE_LENGTH_OF_ARRAY(dedicatedAllocationImageCounts) 568 : DE_LENGTH_OF_ARRAY(coreImageCounts); 569 570 for (size_t countNdx = 0; countNdx < imageCountsLength; countNdx++) 571 { 572 std::ostringstream caseName; 573 caseName << "count_" << imageCounts[countNdx]; 574 de::MovePtr<tcu::TestCaseGroup> countGroup(new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), "")); 575 de::MovePtr<tcu::TestCaseGroup> sizeTests = createImageSizeTests(testCtx, allocationKind, samplingType, imageViewType, imageFormat, imageCounts[countNdx]); 576 577 countGroup->addChild(sizeTests.release()); 578 parentGroup->addChild(countGroup.release()); 579 } 580 } 581 582 de::MovePtr<tcu::TestCaseGroup> createImageFormatTests (tcu::TestContext& testCtx, AllocationKind allocationKind, VkDescriptorType samplingType, VkImageViewType imageViewType) 583 { 584 // All supported dEQP formats that are not intended for depth or stencil. 585 const VkFormat coreFormats[] = 586 { 587 VK_FORMAT_R4G4_UNORM_PACK8, 588 VK_FORMAT_R4G4B4A4_UNORM_PACK16, 589 VK_FORMAT_R5G6B5_UNORM_PACK16, 590 VK_FORMAT_R5G5B5A1_UNORM_PACK16, 591 VK_FORMAT_R8_UNORM, 592 VK_FORMAT_R8_SNORM, 593 VK_FORMAT_R8_USCALED, 594 VK_FORMAT_R8_SSCALED, 595 VK_FORMAT_R8_UINT, 596 VK_FORMAT_R8_SINT, 597 VK_FORMAT_R8_SRGB, 598 VK_FORMAT_R8G8_UNORM, 599 VK_FORMAT_R8G8_SNORM, 600 VK_FORMAT_R8G8_USCALED, 601 VK_FORMAT_R8G8_SSCALED, 602 VK_FORMAT_R8G8_UINT, 603 VK_FORMAT_R8G8_SINT, 604 VK_FORMAT_R8G8_SRGB, 605 VK_FORMAT_R8G8B8_UNORM, 606 VK_FORMAT_R8G8B8_SNORM, 607 VK_FORMAT_R8G8B8_USCALED, 608 VK_FORMAT_R8G8B8_SSCALED, 609 VK_FORMAT_R8G8B8_UINT, 610 VK_FORMAT_R8G8B8_SINT, 611 VK_FORMAT_R8G8B8_SRGB, 612 VK_FORMAT_R8G8B8A8_UNORM, 613 VK_FORMAT_R8G8B8A8_SNORM, 614 VK_FORMAT_R8G8B8A8_USCALED, 615 VK_FORMAT_R8G8B8A8_SSCALED, 616 VK_FORMAT_R8G8B8A8_UINT, 617 VK_FORMAT_R8G8B8A8_SINT, 618 VK_FORMAT_R8G8B8A8_SRGB, 619 VK_FORMAT_A2R10G10B10_UNORM_PACK32, 620 VK_FORMAT_A2R10G10B10_UINT_PACK32, 621 VK_FORMAT_A2R10G10B10_USCALED_PACK32, 622 VK_FORMAT_R16_UNORM, 623 VK_FORMAT_R16_SNORM, 624 VK_FORMAT_R16_USCALED, 625 VK_FORMAT_R16_SSCALED, 626 VK_FORMAT_R16_UINT, 627 VK_FORMAT_R16_SINT, 628 VK_FORMAT_R16_SFLOAT, 629 VK_FORMAT_R16G16_UNORM, 630 VK_FORMAT_R16G16_SNORM, 631 VK_FORMAT_R16G16_USCALED, 632 VK_FORMAT_R16G16_SSCALED, 633 VK_FORMAT_R16G16_UINT, 634 VK_FORMAT_R16G16_SINT, 635 VK_FORMAT_R16G16_SFLOAT, 636 VK_FORMAT_R16G16B16_UNORM, 637 VK_FORMAT_R16G16B16_SNORM, 638 VK_FORMAT_R16G16B16_USCALED, 639 VK_FORMAT_R16G16B16_SSCALED, 640 VK_FORMAT_R16G16B16_UINT, 641 VK_FORMAT_R16G16B16_SINT, 642 VK_FORMAT_R16G16B16_SFLOAT, 643 VK_FORMAT_R16G16B16A16_UNORM, 644 VK_FORMAT_R16G16B16A16_SNORM, 645 VK_FORMAT_R16G16B16A16_USCALED, 646 VK_FORMAT_R16G16B16A16_SSCALED, 647 VK_FORMAT_R16G16B16A16_UINT, 648 VK_FORMAT_R16G16B16A16_SINT, 649 VK_FORMAT_R16G16B16A16_SFLOAT, 650 VK_FORMAT_R32_UINT, 651 VK_FORMAT_R32_SINT, 652 VK_FORMAT_R32_SFLOAT, 653 VK_FORMAT_R32G32_UINT, 654 VK_FORMAT_R32G32_SINT, 655 VK_FORMAT_R32G32_SFLOAT, 656 VK_FORMAT_R32G32B32_UINT, 657 VK_FORMAT_R32G32B32_SINT, 658 VK_FORMAT_R32G32B32_SFLOAT, 659 VK_FORMAT_R32G32B32A32_UINT, 660 VK_FORMAT_R32G32B32A32_SINT, 661 VK_FORMAT_R32G32B32A32_SFLOAT, 662 VK_FORMAT_B10G11R11_UFLOAT_PACK32, 663 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, 664 VK_FORMAT_B4G4R4A4_UNORM_PACK16, 665 VK_FORMAT_B5G5R5A1_UNORM_PACK16, 666 667 // Compressed formats 668 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, 669 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, 670 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, 671 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, 672 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, 673 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, 674 VK_FORMAT_EAC_R11_UNORM_BLOCK, 675 VK_FORMAT_EAC_R11_SNORM_BLOCK, 676 VK_FORMAT_EAC_R11G11_UNORM_BLOCK, 677 VK_FORMAT_EAC_R11G11_SNORM_BLOCK, 678 VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 679 VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 680 VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 681 VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 682 VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 683 VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 684 VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 685 VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 686 VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 687 VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 688 VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 689 VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 690 VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 691 VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 692 VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 693 VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 694 VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 695 VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 696 VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 697 VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 698 VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 699 VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 700 VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 701 VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 702 VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 703 VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 704 VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 705 VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 706 }; 707 // Formats to test with dedicated allocation 708 const VkFormat dedicatedAllocationFormats[] = 709 { 710 VK_FORMAT_R8G8B8A8_UNORM, 711 VK_FORMAT_R16_SFLOAT, 712 }; 713 const VkFormat* formats = (allocationKind == ALLOCATION_KIND_DEDICATED) 714 ? dedicatedAllocationFormats 715 : coreFormats; 716 const size_t formatsLength = (allocationKind == ALLOCATION_KIND_DEDICATED) 717 ? DE_LENGTH_OF_ARRAY(dedicatedAllocationFormats) 718 : DE_LENGTH_OF_ARRAY(coreFormats); 719 720 de::MovePtr<tcu::TestCaseGroup> imageFormatTests(new tcu::TestCaseGroup(testCtx, "format", "Tests samplable formats")); 721 722 for (size_t formatNdx = 0; formatNdx < formatsLength; formatNdx++) 723 { 724 const VkFormat format = formats[formatNdx]; 725 726 if (isCompressedFormat(format)) 727 { 728 // Do not use compressed formats with 1D and 1D array textures. 729 if (imageViewType == VK_IMAGE_VIEW_TYPE_1D || imageViewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY) 730 break; 731 } 732 733 de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, 734 getFormatCaseName(format).c_str(), 735 (std::string("Samples a texture of format ") + getFormatName(format)).c_str())); 736 createImageCountTests(formatGroup.get(), testCtx, allocationKind, samplingType, imageViewType, format); 737 738 imageFormatTests->addChild(formatGroup.release()); 739 } 740 741 return imageFormatTests; 742 } 743 744 de::MovePtr<tcu::TestCaseGroup> createImageViewTypeTests (tcu::TestContext& testCtx, AllocationKind allocationKind, VkDescriptorType samplingType) 745 { 746 const struct 747 { 748 VkImageViewType type; 749 const char* name; 750 } 751 imageViewTypes[] = 752 { 753 { VK_IMAGE_VIEW_TYPE_1D, "1d" }, 754 { VK_IMAGE_VIEW_TYPE_1D_ARRAY, "1d_array" }, 755 { VK_IMAGE_VIEW_TYPE_2D, "2d" }, 756 { VK_IMAGE_VIEW_TYPE_2D_ARRAY, "2d_array" }, 757 { VK_IMAGE_VIEW_TYPE_3D, "3d" }, 758 { VK_IMAGE_VIEW_TYPE_CUBE, "cube" }, 759 { VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, "cube_array" } 760 }; 761 762 de::MovePtr<tcu::TestCaseGroup> imageViewTypeTests(new tcu::TestCaseGroup(testCtx, "view_type", "")); 763 764 for (int viewTypeNdx = 0; viewTypeNdx < DE_LENGTH_OF_ARRAY(imageViewTypes); viewTypeNdx++) 765 { 766 const VkImageViewType viewType = imageViewTypes[viewTypeNdx].type; 767 de::MovePtr<tcu::TestCaseGroup> viewTypeGroup(new tcu::TestCaseGroup(testCtx, imageViewTypes[viewTypeNdx].name, (std::string("Uses a ") + imageViewTypes[viewTypeNdx].name + " view").c_str())); 768 de::MovePtr<tcu::TestCaseGroup> formatTests = createImageFormatTests(testCtx, allocationKind, samplingType, viewType); 769 770 viewTypeGroup->addChild(formatTests.release()); 771 imageViewTypeTests->addChild(viewTypeGroup.release()); 772 } 773 774 return imageViewTypeTests; 775 } 776 777 de::MovePtr<tcu::TestCaseGroup> createImageSamplingTypeTests (tcu::TestContext& testCtx, AllocationKind allocationKind) 778 { 779 VkDescriptorType samplingTypes[] = 780 { 781 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 782 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE 783 }; 784 785 de::MovePtr<tcu::TestCaseGroup> imageSamplingTypeTests(new tcu::TestCaseGroup(testCtx, "sampling_type", "")); 786 787 for (int smpTypeNdx = 0; smpTypeNdx < DE_LENGTH_OF_ARRAY(samplingTypes); smpTypeNdx++) 788 { 789 const char* smpTypeName = samplingTypes[smpTypeNdx] == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ? "combined" : "separate"; 790 de::MovePtr<tcu::TestCaseGroup> samplingTypeGroup(new tcu::TestCaseGroup(testCtx, smpTypeName, (std::string("Uses a ") + smpTypeName + " sampler").c_str())); 791 de::MovePtr<tcu::TestCaseGroup> viewTypeTests = createImageViewTypeTests(testCtx, allocationKind, samplingTypes[smpTypeNdx]); 792 793 samplingTypeGroup->addChild(viewTypeTests.release()); 794 imageSamplingTypeTests->addChild(samplingTypeGroup.release()); 795 } 796 797 return imageSamplingTypeTests; 798 } 799 800 de::MovePtr<tcu::TestCaseGroup> createSuballocationTests(tcu::TestContext& testCtx) 801 { 802 de::MovePtr<tcu::TestCaseGroup> suballocationTestsGroup(new tcu::TestCaseGroup(testCtx, "suballocation", "Suballocation Image Tests")); 803 de::MovePtr<tcu::TestCaseGroup> samplingTypeTests = createImageSamplingTypeTests(testCtx, ALLOCATION_KIND_SUBALLOCATED); 804 805 suballocationTestsGroup->addChild(samplingTypeTests.release()); 806 807 return suballocationTestsGroup; 808 } 809 810 de::MovePtr<tcu::TestCaseGroup> createDedicatedAllocationTests(tcu::TestContext& testCtx) 811 { 812 de::MovePtr<tcu::TestCaseGroup> dedicatedAllocationTestsGroup(new tcu::TestCaseGroup(testCtx, "dedicated_allocation", "Image Tests For Dedicated Allocation")); 813 de::MovePtr<tcu::TestCaseGroup> samplingTypeTests = createImageSamplingTypeTests(testCtx, ALLOCATION_KIND_DEDICATED); 814 815 dedicatedAllocationTestsGroup->addChild(samplingTypeTests.release()); 816 817 return dedicatedAllocationTestsGroup; 818 } 819 } // anonymous 820 821 tcu::TestCaseGroup* createImageTests (tcu::TestContext& testCtx) 822 { 823 de::MovePtr<tcu::TestCaseGroup> imageTests(new tcu::TestCaseGroup(testCtx, "image", "Image tests")); 824 de::MovePtr<tcu::TestCaseGroup> imageSuballocationTests = createSuballocationTests(testCtx); 825 de::MovePtr<tcu::TestCaseGroup> imageDedicatedAllocationTests = createDedicatedAllocationTests(testCtx); 826 827 imageTests->addChild(imageSuballocationTests.release()); 828 imageTests->addChild(imageDedicatedAllocationTests.release()); 829 830 return imageTests.release(); 831 } 832 833 } // pipeline 834 } // vkt 835
