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