external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Image Tests Utility Classes
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktImageTestsUtil.hpp"
  25 #include "vkQueryUtil.hpp"
  26 #include "vkTypeUtil.hpp"
  27 #include "tcuTextureUtil.hpp"
  28
  29 using namespace vk;
  30
  31 namespace vkt
  32 {
  33 namespace image
  34 {
  35
  36 Buffer::Buffer (const DeviceInterface&          vk,
  37                                 const VkDevice                          device,
  38                                 Allocator&                                      allocator,
  39                                 const VkBufferCreateInfo&       bufferCreateInfo,
  40                                 const MemoryRequirement         memoryRequirement)
  41 {
  42         m_buffer = createBuffer(vk, device, &bufferCreateInfo);
  43         m_allocation = allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), memoryRequirement);
  44         VK_CHECK(vk.bindBufferMemory(device, *m_buffer, m_allocation->getMemory(), m_allocation->getOffset()));
  45 }
  46
  47 Image::Image (const DeviceInterface&    vk,
  48                           const VkDevice                        device,
  49                           Allocator&                            allocator,
  50                           const VkImageCreateInfo&      imageCreateInfo,
  51                           const MemoryRequirement       memoryRequirement)
  52 {
  53         m_image = createImage(vk, device, &imageCreateInfo);
  54         m_allocation = allocator.allocate(getImageMemoryRequirements(vk, device, *m_image), memoryRequirement);
  55         VK_CHECK(vk.bindImageMemory(device, *m_image, m_allocation->getMemory(), m_allocation->getOffset()));
  56 }
  57
  58 struct CompressedFormatParameters
  59 {
  60         VkFormat        format;
  61         deUint32        blockBytes;
  62         deUint32        blockWidth;
  63         deUint32        blockHeight;
  64 };
  65
  66 CompressedFormatParameters      compressedFormatParameters[VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_BC1_RGB_UNORM_BLOCK + 1] =
  67 {
  68         { VK_FORMAT_BC1_RGB_UNORM_BLOCK,                8,      4,      4 },
  69         { VK_FORMAT_BC1_RGB_SRGB_BLOCK,                 8,      4,      4 },
  70         { VK_FORMAT_BC1_RGBA_UNORM_BLOCK,               8,      4,      4 },
  71         { VK_FORMAT_BC1_RGBA_SRGB_BLOCK,                8,      4,      4 },
  72         { VK_FORMAT_BC2_UNORM_BLOCK,                    16,     4,      4 },
  73         { VK_FORMAT_BC2_SRGB_BLOCK,                             16,     4,      4 },
  74         { VK_FORMAT_BC3_UNORM_BLOCK,                    16,     4,      4 },
  75         { VK_FORMAT_BC3_SRGB_BLOCK,                             16,     4,      4 },
  76         { VK_FORMAT_BC4_UNORM_BLOCK,                    8,      4,      4 },
  77         { VK_FORMAT_BC4_SNORM_BLOCK,                    8,      4,      4 },
  78         { VK_FORMAT_BC5_UNORM_BLOCK,                    16,     4,      4 },
  79         { VK_FORMAT_BC5_SNORM_BLOCK,                    16,     4,      4 },
  80         { VK_FORMAT_BC6H_UFLOAT_BLOCK,                  16,     4,      4 },
  81         { VK_FORMAT_BC6H_SFLOAT_BLOCK,                  16,     4,      4 },
  82         { VK_FORMAT_BC7_UNORM_BLOCK,                    16,     4,      4 },
  83         { VK_FORMAT_BC7_SRGB_BLOCK,                             16,     4,      4 },
  84         { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,    8,      4,      4 },
  85         { VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,             8,      4,      4 },
  86         { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,  8,      4,      4 },
  87         { VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,   8,      4,      4 },
  88         { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,  16,     4,      4 },
  89         { VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,   16,     4,      4 },
  90         { VK_FORMAT_EAC_R11_UNORM_BLOCK,                8,      4,      4 },
  91         { VK_FORMAT_EAC_R11_SNORM_BLOCK,                8,      4,      4 },
  92         { VK_FORMAT_EAC_R11G11_UNORM_BLOCK,             16,     4,      4 },
  93         { VK_FORMAT_EAC_R11G11_SNORM_BLOCK,             16,     4,      4 },
  94         { VK_FORMAT_ASTC_4x4_UNORM_BLOCK,               16,     4,      4 },
  95         { VK_FORMAT_ASTC_4x4_SRGB_BLOCK,                16,     4,      4 },
  96         { VK_FORMAT_ASTC_5x4_UNORM_BLOCK,               16,     5,      4 },
  97         { VK_FORMAT_ASTC_5x4_SRGB_BLOCK,                16,     5,      4 },
  98         { VK_FORMAT_ASTC_5x5_UNORM_BLOCK,               16,     5,      5 },
  99         { VK_FORMAT_ASTC_5x5_SRGB_BLOCK,                16,     5,      5 },
 100         { VK_FORMAT_ASTC_6x5_UNORM_BLOCK,               16,     6,      5 },
 101         { VK_FORMAT_ASTC_6x5_SRGB_BLOCK,                16,     6,      5 },
 102         { VK_FORMAT_ASTC_6x6_UNORM_BLOCK,               16,     6,      6 },
 103         { VK_FORMAT_ASTC_6x6_SRGB_BLOCK,                16,     6,      6 },
 104         { VK_FORMAT_ASTC_8x5_UNORM_BLOCK,               16,     8,      5 },
 105         { VK_FORMAT_ASTC_8x5_SRGB_BLOCK,                16,     8,      5 },
 106         { VK_FORMAT_ASTC_8x6_UNORM_BLOCK,               16,     8,      6 },
 107         { VK_FORMAT_ASTC_8x6_SRGB_BLOCK,                16,     8,      6 },
 108         { VK_FORMAT_ASTC_8x8_UNORM_BLOCK,               16,     8,      8 },
 109         { VK_FORMAT_ASTC_8x8_SRGB_BLOCK,                16,     8,      8 },
 110         { VK_FORMAT_ASTC_10x5_UNORM_BLOCK,              16,     10,     5 },
 111         { VK_FORMAT_ASTC_10x5_SRGB_BLOCK,               16,     10,     5 },
 112         { VK_FORMAT_ASTC_10x6_UNORM_BLOCK,              16,     10,     6 },
 113         { VK_FORMAT_ASTC_10x6_SRGB_BLOCK,               16,     10,     6 },
 114         { VK_FORMAT_ASTC_10x8_UNORM_BLOCK,              16,     10,     8 },
 115         { VK_FORMAT_ASTC_10x8_SRGB_BLOCK,               16,     10,     8 },
 116         { VK_FORMAT_ASTC_10x10_UNORM_BLOCK,             16,     10,     10 },
 117         { VK_FORMAT_ASTC_10x10_SRGB_BLOCK,              16,     10,     10 },
 118         { VK_FORMAT_ASTC_12x10_UNORM_BLOCK,             16,     12,     10 },
 119         { VK_FORMAT_ASTC_12x10_SRGB_BLOCK,              16,     12,     10 },
 120         { VK_FORMAT_ASTC_12x12_UNORM_BLOCK,             16,     12,     12 },
 121         { VK_FORMAT_ASTC_12x12_SRGB_BLOCK,              16,     12,     12 },
 122 };
 123
 124 deUint32 getBlockSizeInBytes(const VkFormat compressedFormat)
 125 {
 126         deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
 127
 128         DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
 129         DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
 130
 131         return compressedFormatParameters[formatNdx].blockBytes;
 132 }
 133
 134 deUint32 getBlockWidth(const VkFormat compressedFormat)
 135 {
 136         deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
 137
 138         DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
 139         DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
 140
 141         return compressedFormatParameters[formatNdx].blockWidth;
 142 }
 143
 144 deUint32 getBlockHeight(const VkFormat compressedFormat)
 145 {
 146         deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
 147
 148         DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
 149         DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
 150
 151         return compressedFormatParameters[formatNdx].blockHeight;
 152 }
 153
 154 tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize)
 155 {
 156         switch (imageType)
 157         {
 158                 case IMAGE_TYPE_1D:
 159                 case IMAGE_TYPE_BUFFER:
 160                         return tcu::UVec3(imageSize.x(), 1u, 1u);
 161
 162                 case IMAGE_TYPE_1D_ARRAY:
 163                         return tcu::UVec3(imageSize.x(), imageSize.z(), 1u);
 164
 165                 case IMAGE_TYPE_2D:
 166                         return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
 167
 168                 case IMAGE_TYPE_2D_ARRAY:
 169                 case IMAGE_TYPE_3D:
 170                         return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
 171
 172                 case IMAGE_TYPE_CUBE:
 173                         return tcu::UVec3(imageSize.x(), imageSize.y(), 6u);
 174
 175                 case IMAGE_TYPE_CUBE_ARRAY:
 176                         return tcu::UVec3(imageSize.x(), imageSize.y(), 6u * imageSize.z());
 177
 178                 default:
 179                         DE_FATAL("Unknown image type");
 180                         return tcu::UVec3(1u, 1u, 1u);
 181         }
 182 }
 183
 184 tcu::UVec3 getLayerSize (const ImageType imageType, const tcu::UVec3& imageSize)
 185 {
 186         switch (imageType)
 187         {
 188                 case IMAGE_TYPE_1D:
 189                 case IMAGE_TYPE_1D_ARRAY:
 190                 case IMAGE_TYPE_BUFFER:
 191                         return tcu::UVec3(imageSize.x(), 1u, 1u);
 192
 193                 case IMAGE_TYPE_2D:
 194                 case IMAGE_TYPE_2D_ARRAY:
 195                 case IMAGE_TYPE_CUBE:
 196                 case IMAGE_TYPE_CUBE_ARRAY:
 197                         return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
 198
 199                 case IMAGE_TYPE_3D:
 200                         return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
 201
 202                 default:
 203                         DE_FATAL("Unknown image type");
 204                         return tcu::UVec3(1u, 1u, 1u);
 205         }
 206 }
 207
 208 deUint32 getNumLayers (const ImageType imageType, const tcu::UVec3& imageSize)
 209 {
 210         switch (imageType)
 211         {
 212                 case IMAGE_TYPE_1D:
 213                 case IMAGE_TYPE_2D:
 214                 case IMAGE_TYPE_3D:
 215                 case IMAGE_TYPE_BUFFER:
 216                         return 1u;
 217
 218                 case IMAGE_TYPE_1D_ARRAY:
 219                 case IMAGE_TYPE_2D_ARRAY:
 220                         return imageSize.z();
 221
 222                 case IMAGE_TYPE_CUBE:
 223                         return 6u;
 224
 225                 case IMAGE_TYPE_CUBE_ARRAY:
 226                         return imageSize.z() * 6u;
 227
 228                 default:
 229                         DE_FATAL("Unknown image type");
 230                         return 0u;
 231         }
 232 }
 233
 234 deUint32 getNumPixels (const ImageType imageType, const tcu::UVec3& imageSize)
 235 {
 236         const tcu::UVec3 gridSize = getShaderGridSize(imageType, imageSize);
 237
 238         return gridSize.x() * gridSize.y() * gridSize.z();
 239 }
 240
 241 deUint32 getDimensions (const ImageType imageType)
 242 {
 243         switch (imageType)
 244         {
 245                 case IMAGE_TYPE_1D:
 246                 case IMAGE_TYPE_BUFFER:
 247                         return 1u;
 248
 249                 case IMAGE_TYPE_1D_ARRAY:
 250                 case IMAGE_TYPE_2D:
 251                         return 2u;
 252
 253                 case IMAGE_TYPE_2D_ARRAY:
 254                 case IMAGE_TYPE_CUBE:
 255                 case IMAGE_TYPE_CUBE_ARRAY:
 256                 case IMAGE_TYPE_3D:
 257                         return 3u;
 258
 259                 default:
 260                         DE_FATAL("Unknown image type");
 261                         return 0u;
 262         }
 263 }
 264
 265 deUint32 getLayerDimensions (const ImageType imageType)
 266 {
 267         switch (imageType)
 268         {
 269                 case IMAGE_TYPE_1D:
 270                 case IMAGE_TYPE_BUFFER:
 271                 case IMAGE_TYPE_1D_ARRAY:
 272                         return 1u;
 273
 274                 case IMAGE_TYPE_2D:
 275                 case IMAGE_TYPE_2D_ARRAY:
 276                 case IMAGE_TYPE_CUBE:
 277                 case IMAGE_TYPE_CUBE_ARRAY:
 278                         return 2u;
 279
 280                 case IMAGE_TYPE_3D:
 281                         return 3u;
 282
 283                 default:
 284                         DE_FATAL("Unknown image type");
 285                         return 0u;
 286         }
 287 }
 288
 289 std::vector<tcu::UVec3> getMipLevelSizes (tcu::UVec3 baseSize)
 290 {
 291         std::vector<tcu::UVec3> levels;
 292         levels.push_back(baseSize);
 293
 294         while (baseSize.x() != 1 || baseSize.y() != 1 || baseSize.z() != 1)
 295         {
 296                 baseSize.x() = deMax32(baseSize.x() >> 1, 1);
 297                 baseSize.y() = deMax32(baseSize.y() >> 1, 1);
 298                 baseSize.z() = deMax32(baseSize.z() >> 1, 1);
 299                 levels.push_back(baseSize);
 300         }
 301
 302         return levels;
 303 }
 304
 305 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize                     bufferSize,
 306                                                                                  const VkBufferUsageFlags       usage)
 307 {
 308         const VkBufferCreateInfo bufferCreateInfo =
 309         {
 310                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,   // VkStructureType              sType;
 311                 DE_NULL,                                                                // const void*                  pNext;
 312                 0u,                                                                             // VkBufferCreateFlags  flags;
 313                 bufferSize,                                                             // VkDeviceSize                 size;
 314                 usage,                                                                  // VkBufferUsageFlags   usage;
 315                 VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
 316                 0u,                                                                             // deUint32                             queueFamilyIndexCount;
 317                 DE_NULL,                                                                // const deUint32*              pQueueFamilyIndices;
 318         };
 319         return bufferCreateInfo;
 320 }
 321
 322 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
 323                                                                            const deUint32       arraySize)
 324 {
 325         const VkBufferImageCopy copyParams =
 326         {
 327                 0ull,                                                                                                                                           //      VkDeviceSize                            bufferOffset;
 328                 0u,                                                                                                                                                     //      deUint32                                        bufferRowLength;
 329                 0u,                                                                                                                                                     //      deUint32                                        bufferImageHeight;
 330                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize),       //      VkImageSubresourceLayers        imageSubresource;
 331                 makeOffset3D(0, 0, 0),                                                                                                          //      VkOffset3D                                      imageOffset;
 332                 extent,                                                                                                                                         //      VkExtent3D                                      imageExtent;
 333         };
 334         return copyParams;
 335 }
 336
 337 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface&               vk,
 338                                                                                    const VkDevice                               device,
 339                                                                                    const VkDescriptorSetLayout  descriptorSetLayout)
 340 {
 341         const VkPipelineLayoutCreateInfo pipelineLayoutParams =
 342         {
 343                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,          // VkStructureType                                      sType;
 344                 DE_NULL,                                                                                        // const void*                                          pNext;
 345                 0u,                                                                                                     // VkPipelineLayoutCreateFlags          flags;
 346                 1u,                                                                                                     // deUint32                                                     setLayoutCount;
 347                 &descriptorSetLayout,                                                           // const VkDescriptorSetLayout*         pSetLayouts;
 348                 0u,                                                                                                     // deUint32                                                     pushConstantRangeCount;
 349                 DE_NULL,                                                                                        // const VkPushConstantRange*           pPushConstantRanges;
 350         };
 351         return createPipelineLayout(vk, device, &pipelineLayoutParams);
 352 }
 353
 354 Move<VkPipeline> makeComputePipeline (const DeviceInterface&    vk,
 355                                                                           const VkDevice                        device,
 356                                                                           const VkPipelineLayout        pipelineLayout,
 357                                                                           const VkShaderModule          shaderModule)
 358 {
 359         const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
 360         {
 361                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,    // VkStructureType                                              sType;
 362                 DE_NULL,                                                                                                // const void*                                                  pNext;
 363                 0u,                                                                                                             // VkPipelineShaderStageCreateFlags             flags;
 364                 VK_SHADER_STAGE_COMPUTE_BIT,                                                    // VkShaderStageFlagBits                                stage;
 365                 shaderModule,                                                                                   // VkShaderModule                                               module;
 366                 "main",                                                                                                 // const char*                                                  pName;
 367                 DE_NULL,                                                                                                // const VkSpecializationInfo*                  pSpecializationInfo;
 368         };
 369         const VkComputePipelineCreateInfo pipelineCreateInfo =
 370         {
 371                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,         // VkStructureType                                      sType;
 372                 DE_NULL,                                                                                        // const void*                                          pNext;
 373                 0u,                                                                                                     // VkPipelineCreateFlags                        flags;
 374                 pipelineShaderStageParams,                                                      // VkPipelineShaderStageCreateInfo      stage;
 375                 pipelineLayout,                                                                         // VkPipelineLayout                                     layout;
 376                 DE_NULL,                                                                                        // VkPipeline                                           basePipelineHandle;
 377                 0,                                                                                                      // deInt32                                                      basePipelineIndex;
 378         };
 379         return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo);
 380 }
 381
 382 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface&   vk,
 383                                                                            const VkDevice                       device,
 384                                                                            const VkPipelineLayout       pipelineLayout,
 385                                                                            const VkRenderPass           renderPass,
 386                                                                            const VkShaderModule         vertexModule,
 387                                                                            const VkShaderModule         fragmentModule,
 388                                                                            const VkExtent2D                     renderSize,
 389                                                                            const deUint32                       colorAttachmentCount)
 390 {
 391         const VkFormat  vertexFormatPosition            = VK_FORMAT_R32G32B32A32_SFLOAT;
 392         const deUint32  vertexSizePosition                      = tcu::getPixelSize(mapVkFormat(vertexFormatPosition));
 393         const deUint32  vertexBufferOffsetPosition      = 0u;
 394         const deUint32  vertexDataStride                        = vertexSizePosition;
 395
 396         const VkVertexInputBindingDescription vertexBinding =
 397         {
 398                 0u,                                                                                                                             // deUint32                                                                             binding;
 399                 vertexDataStride,                                                                                               // deUint32                                                                             stride;
 400                 VK_VERTEX_INPUT_RATE_VERTEX                                                                             // VkVertexInputRate                                                    inputRate;
 401         };
 402
 403         const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
 404         {
 405                 // position
 406                 {
 407                         0u,                                                                                                                     // deUint32                                                                             location;
 408                         0u,                                                                                                                     // deUint32                                                                             binding;
 409                         vertexFormatPosition,                                                                           // VkFormat                                                                             format;
 410                         vertexBufferOffsetPosition,                                                                     // deUint32                                                                             offset;
 411                 },
 412         };
 413
 414         const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
 415         {
 416                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,              // VkStructureType                                                              sType;
 417                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 418                 (VkPipelineVertexInputStateCreateFlags)0,                                               // VkPipelineVertexInputStateCreateFlags                flags;
 419                 1u,                                                                                                                             // uint32_t                                                                             vertexBindingDescriptionCount;
 420                 &vertexBinding,                                                                                                 // const VkVertexInputBindingDescription*               pVertexBindingDescriptions;
 421                 DE_LENGTH_OF_ARRAY(vertexInputAttributeDescriptions),                   // uint32_t                                                                             vertexAttributeDescriptionCount;
 422                 vertexInputAttributeDescriptions,                                                               // const VkVertexInputAttributeDescription*             pVertexAttributeDescriptions;
 423         };
 424
 425         const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
 426         {
 427                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // VkStructureType                                                              sType;
 428                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 429                 (VkPipelineInputAssemblyStateCreateFlags)0,                                             // VkPipelineInputAssemblyStateCreateFlags              flags;
 430                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                                                    // VkPrimitiveTopology                                                  topology;
 431                 VK_FALSE,                                                                                                               // VkBool32                                                                             primitiveRestartEnable;
 432         };
 433
 434         const VkViewport viewport =
 435         {
 436                 0.0f,                                                                                                                   // float                                                                                originX;
 437                 0.0f,                                                                                                                   // float                                                                                originY;
 438                 (float)renderSize.width,                                                                                // float                                                                                width;
 439                 (float)renderSize.height,                                                                               // float                                                                                height;
 440                 0.0f,                                                                                                                   // float                                                                                minDepth;
 441                 1.0f                                                                                                                    // float                                                                                maxDepth;
 442         };
 443
 444         const VkRect2D scissor =
 445         {
 446                 { 0u, 0u },                                                                                                             // VkOffset2D                                                                   offset;
 447                 renderSize                                                                                                              // VkExtent2D                                                                   extent;
 448         };
 449
 450         const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
 451         {
 452                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,                  // VkStructureType                                                              sType;
 453                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 454                 (VkPipelineViewportStateCreateFlags)0,                                                  // VkPipelineViewportStateCreateFlags                   flags;
 455                 1u,                                                                                                                             // uint32_t                                                                             viewportCount;
 456                 &viewport, // dynamic state                                                                             // const VkViewport*                                                    pViewports;
 457                 1u,                                                                                                                             // uint32_t                                                                             scissorCount;
 458                 &scissor, // dynamic state                                                                              // const VkRect2D*                                                              pScissors;
 459         };
 460
 461         const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
 462         {
 463                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,             // VkStructureType                                                              sType;
 464                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 465                 (VkPipelineRasterizationStateCreateFlags)0,                                             // VkPipelineRasterizationStateCreateFlags              flags;
 466                 VK_FALSE,                                                                                                               // VkBool32                                                                             depthClampEnable;
 467                 VK_FALSE,                                                                                                               // VkBool32                                                                             rasterizerDiscardEnable;
 468                 VK_POLYGON_MODE_FILL,                                                                                   // VkPolygonMode                                                                polygonMode;
 469                 VK_CULL_MODE_NONE,                                                                                              // VkCullModeFlags                                                              cullMode;
 470                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                                                // VkFrontFace                                                                  frontFace;
 471                 VK_FALSE,                                                                                                               // VkBool32                                                                             depthBiasEnable;
 472                 0.0f,                                                                                                                   // float                                                                                depthBiasConstantFactor;
 473                 0.0f,                                                                                                                   // float                                                                                depthBiasClamp;
 474                 0.0f,                                                                                                                   // float                                                                                depthBiasSlopeFactor;
 475                 1.0f,                                                                                                                   // float                                                                                lineWidth;
 476         };
 477
 478         const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
 479         {
 480                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,               // VkStructureType                                                              sType;
 481                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 482                 (VkPipelineMultisampleStateCreateFlags)0,                                               // VkPipelineMultisampleStateCreateFlags                flags;
 483                 VK_SAMPLE_COUNT_1_BIT,                                                                                  // VkSampleCountFlagBits                                                rasterizationSamples;
 484                 VK_FALSE,                                                                                                               // VkBool32                                                                             sampleShadingEnable;
 485                 0.0f,                                                                                                                   // float                                                                                minSampleShading;
 486                 DE_NULL,                                                                                                                // const VkSampleMask*                                                  pSampleMask;
 487                 VK_FALSE,                                                                                                               // VkBool32                                                                             alphaToCoverageEnable;
 488                 VK_FALSE                                                                                                                // VkBool32                                                                             alphaToOneEnable;
 489         };
 490
 491         const VkColorComponentFlags                                     colorComponentsAll                      = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 492         const VkPipelineColorBlendAttachmentState       colorBlendAttachmentState       =
 493         {
 494                 VK_FALSE,                                                                                                               // VkBool32                                                                             blendEnable;
 495                 VK_BLEND_FACTOR_ONE,                                                                                    // VkBlendFactor                                                                srcColorBlendFactor;
 496                 VK_BLEND_FACTOR_ZERO,                                                                                   // VkBlendFactor                                                                dstColorBlendFactor;
 497                 VK_BLEND_OP_ADD,                                                                                                // VkBlendOp                                                                    colorBlendOp;
 498                 VK_BLEND_FACTOR_ONE,                                                                                    // VkBlendFactor                                                                srcAlphaBlendFactor;
 499                 VK_BLEND_FACTOR_ZERO,                                                                                   // VkBlendFactor                                                                dstAlphaBlendFactor;
 500                 VK_BLEND_OP_ADD,                                                                                                // VkBlendOp                                                                    alphaBlendOp;
 501                 colorComponentsAll,                                                                                             // VkColorComponentFlags                                                colorWriteMask;
 502         };
 503         std::vector<VkPipelineColorBlendAttachmentState> colorAttachments(colorAttachmentCount, colorBlendAttachmentState);
 504
 505         const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
 506         {
 507                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,               // VkStructureType                                                              sType;
 508                 DE_NULL,                                                                                                                // const void*                                                                  pNext;
 509                 (VkPipelineColorBlendStateCreateFlags)0,                                                // VkPipelineColorBlendStateCreateFlags                 flags;
 510                 VK_FALSE,                                                                                                               // VkBool32                                                                             logicOpEnable;
 511                 VK_LOGIC_OP_COPY,                                                                                               // VkLogicOp                                                                    logicOp;
 512                 (deUint32)colorAttachments.size(),                                                              // deUint32                                                                             attachmentCount;
 513                 colorAttachments.size() != 0 ? &colorAttachments[0] : DE_NULL,  // const VkPipelineColorBlendAttachmentState*   pAttachments;
 514                 { 0.0f, 0.0f, 0.0f, 0.0f },                                                                             // float                                                                                blendConstants[4];
 515         };
 516
 517         const VkPipelineShaderStageCreateInfo pShaderStages[] =
 518         {
 519                 {
 520                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                                              sType;
 521                         DE_NULL,                                                                                                        // const void*                                                                  pNext;
 522                         (VkPipelineShaderStageCreateFlags)0,                                            // VkPipelineShaderStageCreateFlags                             flags;
 523                         VK_SHADER_STAGE_VERTEX_BIT,                                                                     // VkShaderStageFlagBits                                                stage;
 524                         vertexModule,                                                                                           // VkShaderModule                                                               module;
 525                         "main",                                                                                                         // const char*                                                                  pName;
 526                         DE_NULL,                                                                                                        // const VkSpecializationInfo*                                  pSpecializationInfo;
 527                 },
 528                 {
 529                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                                              sType;
 530                         DE_NULL,                                                                                                        // const void*                                                                  pNext;
 531                         (VkPipelineShaderStageCreateFlags)0,                                            // VkPipelineShaderStageCreateFlags                             flags;
 532                         VK_SHADER_STAGE_FRAGMENT_BIT,                                                           // VkShaderStageFlagBits                                                stage;
 533                         fragmentModule,                                                                                         // VkShaderModule                                                               module;
 534                         "main",                                                                                                         // const char*                                                                  pName;
 535                         DE_NULL,                                                                                                        // const VkSpecializationInfo*                                  pSpecializationInfo;
 536                 }
 537         };
 538
 539         const deUint32 numActiveShaderStages = DE_LENGTH_OF_ARRAY(pShaderStages);
 540
 541         const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
 542         {
 543                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,                                // VkStructureType                                                                      sType;
 544                 DE_NULL,                                                                                                                // const void*                                                                          pNext;
 545                 (VkPipelineCreateFlags)0,                                                                               // VkPipelineCreateFlags                                                        flags;
 546                 numActiveShaderStages,                                                                                  // deUint32                                                                                     stageCount;
 547                 pShaderStages,                                                                                                  // const VkPipelineShaderStageCreateInfo*                       pStages;
 548                 &vertexInputStateInfo,                                                                                  // const VkPipelineVertexInputStateCreateInfo*          pVertexInputState;
 549                 &pipelineInputAssemblyStateInfo,                                                                // const VkPipelineInputAssemblyStateCreateInfo*        pInputAssemblyState;
 550                 DE_NULL,                                                                                                                // const VkPipelineTessellationStateCreateInfo*         pTessellationState;
 551                 &pipelineViewportStateInfo,                                                                             // const VkPipelineViewportStateCreateInfo*                     pViewportState;
 552                 &pipelineRasterizationStateInfo,                                                                // const VkPipelineRasterizationStateCreateInfo*        pRasterizationState;
 553                 &pipelineMultisampleStateInfo,                                                                  // const VkPipelineMultisampleStateCreateInfo*          pMultisampleState;
 554                 DE_NULL,                                                                                                                // const VkPipelineDepthStencilStateCreateInfo*         pDepthStencilState;
 555                 &pipelineColorBlendStateInfo,                                                                   // const VkPipelineColorBlendStateCreateInfo*           pColorBlendState;
 556                 DE_NULL,                                                                                                                // const VkPipelineDynamicStateCreateInfo*                      pDynamicState;
 557                 pipelineLayout,                                                                                                 // VkPipelineLayout                                                                     layout;
 558                 renderPass,                                                                                                             // VkRenderPass                                                                         renderPass;
 559                 0u,                                                                                                                             // deUint32                                                                                     subpass;
 560                 DE_NULL,                                                                                                                // VkPipeline                                                                           basePipelineHandle;
 561                 0,                                                                                                                              // deInt32                                                                                      basePipelineIndex;
 562         };
 563
 564         return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
 565 }
 566
 567 //! A single-subpass render pass.
 568 Move<VkRenderPass> makeRenderPass (const DeviceInterface&       vk,
 569                                                                    const VkDevice                       device,
 570                                                                    const VkFormat                       inputFormat,
 571                                                                    const VkFormat                       colorFormat)
 572 {
 573         const VkAttachmentReference             inputAttachmentRef                      =
 574         {
 575                 0u,                                                                                                                     // deUint32                     attachment;
 576                 VK_IMAGE_LAYOUT_GENERAL                                                                         // VkImageLayout        layout;
 577         };
 578
 579         const VkAttachmentReference             colorAttachmentRef                      =
 580         {
 581                 1u,                                                                                                                     // deUint32                     attachment;
 582                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                                        // VkImageLayout        layout;
 583         };
 584
 585         const VkSubpassDescription              subpassDescription                      =
 586         {
 587                 (VkSubpassDescriptionFlags)0,                                                           // VkSubpassDescriptionFlags            flags;
 588                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                                        // VkPipelineBindPoint                          pipelineBindPoint;
 589                 1u,                                                                                                                     // deUint32                                                     inputAttachmentCount;
 590                 &inputAttachmentRef,                                                                            // const VkAttachmentReference*         pInputAttachments;
 591                 1u,                                                                                                                     // deUint32                                                     colorAttachmentCount;
 592                 &colorAttachmentRef,                                                                            // const VkAttachmentReference*         pColorAttachments;
 593                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pResolveAttachments;
 594                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pDepthStencilAttachment;
 595                 0u,                                                                                                                     // deUint32                                                     preserveAttachmentCount;
 596                 DE_NULL                                                                                                         // const deUint32*                                      pPreserveAttachments;
 597         };
 598
 599         const VkAttachmentDescription   attachmentsDescriptions[]       =
 600         {
 601                 //inputAttachmentDescription,
 602                 {
 603                         (VkAttachmentDescriptionFlags)0,                                                // VkAttachmentDescriptionFlags         flags;
 604                         inputFormat,                                                                                    // VkFormat                                                     format;
 605                         VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits                        samples;
 606                         VK_ATTACHMENT_LOAD_OP_LOAD,                                                             // VkAttachmentLoadOp                           loadOp;
 607                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                                               // VkAttachmentStoreOp                          storeOp;
 608                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                                // VkAttachmentLoadOp                           stencilLoadOp;
 609                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                                               // VkAttachmentStoreOp                          stencilStoreOp;
 610                         VK_IMAGE_LAYOUT_GENERAL,                                                                // VkImageLayout                                        initialLayout;
 611                         VK_IMAGE_LAYOUT_GENERAL,                                                                // VkImageLayout                                        finalLayout;
 612                 },
 613                 //colorAttachmentDescription
 614                 {
 615                         (VkAttachmentDescriptionFlags)0,                                                // VkAttachmentDescriptionFlags         flags;
 616                         colorFormat,                                                                                    // VkFormat                                                     format;
 617                         VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits                        samples;
 618                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                                    // VkAttachmentLoadOp                           loadOp;
 619                         VK_ATTACHMENT_STORE_OP_STORE,                                                   // VkAttachmentStoreOp                          storeOp;
 620                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                                // VkAttachmentLoadOp                           stencilLoadOp;
 621                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                                               // VkAttachmentStoreOp                          stencilStoreOp;
 622                         VK_IMAGE_LAYOUT_UNDEFINED,                                                              // VkImageLayout                                        initialLayout;
 623                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                               // VkImageLayout                                        finalLayout;
 624                 }
 625         };
 626
 627         const VkRenderPassCreateInfo    renderPassInfo                          =
 628         {
 629                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                                      // VkStructureType                                      sType;
 630                 DE_NULL,                                                                                                        // const void*                                          pNext;
 631                 (VkRenderPassCreateFlags)0,                                                                     // VkRenderPassCreateFlags                      flags;
 632                 DE_LENGTH_OF_ARRAY(attachmentsDescriptions),                            // deUint32                                                     attachmentCount;
 633                 attachmentsDescriptions,                                                                        // const VkAttachmentDescription*       pAttachments;
 634                 1u,                                                                                                                     // deUint32                                                     subpassCount;
 635                 &subpassDescription,                                                                            // const VkSubpassDescription*          pSubpasses;
 636                 0u,                                                                                                                     // deUint32                                                     dependencyCount;
 637                 DE_NULL                                                                                                         // const VkSubpassDependency*           pDependencies;
 638         };
 639
 640         return createRenderPass(vk, device, &renderPassInfo);
 641 }
 642
 643 //! A single-subpass render pass.
 644 Move<VkRenderPass> makeRenderPass (const DeviceInterface&       vk,
 645                                                                    const VkDevice                       device)
 646 {
 647         const VkSubpassDescription              subpassDescription                      =
 648         {
 649                 (VkSubpassDescriptionFlags)0,                                                           // VkSubpassDescriptionFlags            flags;
 650                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                                        // VkPipelineBindPoint                          pipelineBindPoint;
 651                 0u,                                                                                                                     // deUint32                                                     inputAttachmentCount;
 652                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pInputAttachments;
 653                 0u,                                                                                                                     // deUint32                                                     colorAttachmentCount;
 654                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pColorAttachments;
 655                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pResolveAttachments;
 656                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pDepthStencilAttachment;
 657                 0u,                                                                                                                     // deUint32                                                     preserveAttachmentCount;
 658                 DE_NULL                                                                                                         // const deUint32*                                      pPreserveAttachments;
 659         };
 660
 661         const VkRenderPassCreateInfo    renderPassInfo                          =
 662         {
 663                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                                      // VkStructureType                                      sType;
 664                 DE_NULL,                                                                                                        // const void*                                          pNext;
 665                 (VkRenderPassCreateFlags)0,                                                                     // VkRenderPassCreateFlags                      flags;
 666                 0,                                                                                                                      // deUint32                                                     attachmentCount;
 667                 DE_NULL,                                                                                                        // const VkAttachmentDescription*       pAttachments;
 668                 1u,                                                                                                                     // deUint32                                                     subpassCount;
 669                 &subpassDescription,                                                                            // const VkSubpassDescription*          pSubpasses;
 670                 0u,                                                                                                                     // deUint32                                                     dependencyCount;
 671                 DE_NULL                                                                                                         // const VkSubpassDependency*           pDependencies;
 672         };
 673
 674         return createRenderPass(vk, device, &renderPassInfo);
 675 }
 676
 677 Move<VkBufferView> makeBufferView (const DeviceInterface&       vk,
 678                                                                    const VkDevice                       vkDevice,
 679                                                                    const VkBuffer                       buffer,
 680                                                                    const VkFormat                       format,
 681                                                                    const VkDeviceSize           offset,
 682                                                                    const VkDeviceSize           size)
 683 {
 684         const VkBufferViewCreateInfo bufferViewParams =
 685         {
 686                 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,      // VkStructureType                      sType;
 687                 DE_NULL,                                                                        // const void*                          pNext;
 688                 0u,                                                                                     // VkBufferViewCreateFlags      flags;
 689                 buffer,                                                                         // VkBuffer                                     buffer;
 690                 format,                                                                         // VkFormat                                     format;
 691                 offset,                                                                         // VkDeviceSize                         offset;
 692                 size,                                                                           // VkDeviceSize                         range;
 693         };
 694         return createBufferView(vk, vkDevice, &bufferViewParams);
 695 }
 696
 697 Move<VkImageView> makeImageView (const DeviceInterface&                                 vk,
 698                                                                  const VkDevice                                                 vkDevice,
 699                                                                  const VkImage                                                  image,
 700                                                                  const VkImageViewType                                  imageViewType,
 701                                                                  const VkFormat                                                 format,
 702                                                                  const VkImageSubresourceRange                  subresourceRange,
 703                                                                  const VkImageViewUsageCreateInfoKHR*   ImageUsageCreateInfoKHR)
 704 {
 705         const VkImageViewCreateInfo imageViewParams =
 706         {
 707                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,               // VkStructureType                      sType;
 708                 ImageUsageCreateInfoKHR,                                                // const void*                          pNext;
 709                 0u,                                                                                             // VkImageViewCreateFlags       flags;
 710                 image,                                                                                  // VkImage                                      image;
 711                 imageViewType,                                                                  // VkImageViewType                      viewType;
 712                 format,                                                                                 // VkFormat                                     format;
 713                 makeComponentMappingRGBA(),                                             // VkComponentMapping           components;
 714                 subresourceRange,                                                               // VkImageSubresourceRange      subresourceRange;
 715         };
 716         return createImageView(vk, vkDevice, &imageViewParams);
 717 }
 718
 719 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface&                 vk,
 720                                                                                  const VkDevice                                 device,
 721                                                                                  const VkDescriptorPool                 descriptorPool,
 722                                                                                  const VkDescriptorSetLayout    setLayout)
 723 {
 724         const VkDescriptorSetAllocateInfo allocateParams =
 725         {
 726                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,         // VkStructureType                              sType;
 727                 DE_NULL,                                                                                        // const void*                                  pNext;
 728                 descriptorPool,                                                                         // VkDescriptorPool                             descriptorPool;
 729                 1u,                                                                                                     // deUint32                                             setLayoutCount;
 730                 &setLayout,                                                                                     // const VkDescriptorSetLayout* pSetLayouts;
 731         };
 732         return allocateDescriptorSet(vk, device, &allocateParams);
 733 }
 734
 735 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags      srcAccessMask,
 736                                                                                            const VkAccessFlags  dstAccessMask,
 737                                                                                            const VkBuffer               buffer,
 738                                                                                            const VkDeviceSize   offset,
 739                                                                                            const VkDeviceSize   bufferSizeBytes)
 740 {
 741         const VkBufferMemoryBarrier barrier =
 742         {
 743                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 744                 DE_NULL,                                                                        // const void*          pNext;
 745                 srcAccessMask,                                                          // VkAccessFlags        srcAccessMask;
 746                 dstAccessMask,                                                          // VkAccessFlags        dstAccessMask;
 747                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 748                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     destQueueFamilyIndex;
 749                 buffer,                                                                         // VkBuffer                     buffer;
 750                 offset,                                                                         // VkDeviceSize         offset;
 751                 bufferSizeBytes,                                                        // VkDeviceSize         size;
 752         };
 753         return barrier;
 754 }
 755
 756 VkImageMemoryBarrier makeImageMemoryBarrier     (const VkAccessFlags                    srcAccessMask,
 757                                                                                          const VkAccessFlags                    dstAccessMask,
 758                                                                                          const VkImageLayout                    oldLayout,
 759                                                                                          const VkImageLayout                    newLayout,
 760                                                                                          const VkImage                                  image,
 761                                                                                          const VkImageSubresourceRange  subresourceRange)
 762 {
 763         const VkImageMemoryBarrier barrier =
 764         {
 765                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 766                 DE_NULL,                                                                                // const void*                          pNext;
 767                 srcAccessMask,                                                                  // VkAccessFlags                        outputMask;
 768                 dstAccessMask,                                                                  // VkAccessFlags                        inputMask;
 769                 oldLayout,                                                                              // VkImageLayout                        oldLayout;
 770                 newLayout,                                                                              // VkImageLayout                        newLayout;
 771                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 772                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     destQueueFamilyIndex;
 773                 image,                                                                                  // VkImage                                      image;
 774                 subresourceRange,                                                               // VkImageSubresourceRange      subresourceRange;
 775         };
 776         return barrier;
 777 }
 778
 779 VkSamplerCreateInfo makeSamplerCreateInfo ()
 780 {
 781         const VkSamplerCreateInfo defaultSamplerParams =
 782         {
 783                 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,          // VkStructureType                      sType;
 784                 DE_NULL,                                                                        // const void*                          pNext;
 785                 0u,                                                                                     // VkSamplerCreateFlags         flags;
 786                 VK_FILTER_NEAREST,                                                      // VkFilter                                     magFilter;
 787                 VK_FILTER_NEAREST,                                                      // VkFilter                                     minFilter;
 788                 VK_SAMPLER_MIPMAP_MODE_NEAREST,                         // VkSamplerMipmapMode          mipmapMode;
 789                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // VkSamplerAddressMode         addressModeU;
 790                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // VkSamplerAddressMode         addressModeV;
 791                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // VkSamplerAddressMode         addressModeW;
 792                 0.0f,                                                                           // float                                        mipLodBias;
 793                 VK_FALSE,                                                                       // VkBool32                                     anisotropyEnable;
 794                 1.0f,                                                                           // float                                        maxAnisotropy;
 795                 false,                                                                          // VkBool32                                     compareEnable;
 796                 VK_COMPARE_OP_NEVER,                                            // VkCompareOp                          compareOp;
 797                 0.0f,                                                                           // float                                        minLod;
 798                 0.25f,                                                                          // float                                        maxLod;
 799                 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,        // VkBorderColor                        borderColor;
 800                 false                                                                           // VkBool32                                     unnormalizedCoordinates;
 801         };
 802
 803         return defaultSamplerParams;
 804 }
 805
 806 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 807 {
 808         const VkCommandBufferBeginInfo commandBufBeginParams =
 809         {
 810                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                                      sType;
 811                 DE_NULL,                                                                                // const void*                                          pNext;
 812                 0u,                                                                                             // VkCommandBufferUsageFlags            flags;
 813                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 814         };
 815         VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufBeginParams));
 816 }
 817 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 818 {
 819         VK_CHECK(vk.endCommandBuffer(commandBuffer));
 820 }
 821
 822 void submitCommandsAndWait (const DeviceInterface&      vk,
 823                                                         const VkDevice                  device,
 824                                                         const VkQueue                   queue,
 825                                                         const VkCommandBuffer   commandBuffer)
 826 {
 827         const Unique<VkFence> fence(createFence(vk, device));
 828
 829         const VkSubmitInfo submitInfo =
 830         {
 831                 VK_STRUCTURE_TYPE_SUBMIT_INFO,          // VkStructureType                      sType;
 832                 DE_NULL,                                                        // const void*                          pNext;
 833                 0u,                                                                     // deUint32                                     waitSemaphoreCount;
 834                 DE_NULL,                                                        // const VkSemaphore*           pWaitSemaphores;
 835                 (const VkPipelineStageFlags*)DE_NULL,
 836                 1u,                                                                     // deUint32                                     commandBufferCount;
 837                 &commandBuffer,                                         // const VkCommandBuffer*       pCommandBuffers;
 838                 0u,                                                                     // deUint32                                     signalSemaphoreCount;
 839                 DE_NULL,                                                        // const VkSemaphore*           pSignalSemaphores;
 840         };
 841
 842         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 843         VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
 844 }
 845
 846 tcu::UVec3 getCompressedImageResolutionInBlocks(const vk::VkFormat format, const tcu::UVec3 size)
 847 {
 848         deUint32        blockWidth      = getBlockWidth(format);
 849         deUint32        blockHeight     = getBlockHeight(format);
 850
 851         DE_ASSERT(size[2] == 1);
 852         DE_ASSERT(blockWidth != 0 && blockHeight != 0);
 853
 854         deUint32        widthInBlocks   = (size[0] + blockWidth - 1) / blockWidth;
 855         deUint32        heightInBlocks  = (size[1] + blockHeight - 1) / blockHeight;
 856
 857         return tcu::UVec3(widthInBlocks, heightInBlocks, 1);
 858 }
 859
 860 VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
 861 {
 862         tcu::UVec3              sizeInBlocks    = getCompressedImageResolutionInBlocks(format, size);
 863         deUint32                blockBytes              = getBlockSizeInBytes(format);
 864         VkDeviceSize    sizeBytes               = sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes;
 865
 866         return sizeBytes;
 867 }
 868
 869 VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
 870 {
 871         const tcu::IVec3        sizeAsIVec3     = tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z());
 872         const VkDeviceSize      sizeBytes       = getImageSizeBytes(sizeAsIVec3, format);
 873
 874         return sizeBytes;
 875 }
 876
 877 VkImageType     mapImageType (const ImageType imageType)
 878 {
 879         switch (imageType)
 880         {
 881                 case IMAGE_TYPE_1D:
 882                 case IMAGE_TYPE_1D_ARRAY:
 883                 case IMAGE_TYPE_BUFFER:
 884                         return VK_IMAGE_TYPE_1D;
 885
 886                 case IMAGE_TYPE_2D:
 887                 case IMAGE_TYPE_2D_ARRAY:
 888                 case IMAGE_TYPE_CUBE:
 889                 case IMAGE_TYPE_CUBE_ARRAY:
 890                         return VK_IMAGE_TYPE_2D;
 891
 892                 case IMAGE_TYPE_3D:
 893                         return VK_IMAGE_TYPE_3D;
 894
 895                 default:
 896                         DE_ASSERT(false);
 897                         return VK_IMAGE_TYPE_LAST;
 898         }
 899 }
 900
 901 VkImageViewType mapImageViewType (const ImageType imageType)
 902 {
 903         switch (imageType)
 904         {
 905                 case IMAGE_TYPE_1D:                     return VK_IMAGE_VIEW_TYPE_1D;
 906                 case IMAGE_TYPE_1D_ARRAY:       return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
 907                 case IMAGE_TYPE_2D:                     return VK_IMAGE_VIEW_TYPE_2D;
 908                 case IMAGE_TYPE_2D_ARRAY:       return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 909                 case IMAGE_TYPE_3D:                     return VK_IMAGE_VIEW_TYPE_3D;
 910                 case IMAGE_TYPE_CUBE:           return VK_IMAGE_VIEW_TYPE_CUBE;
 911                 case IMAGE_TYPE_CUBE_ARRAY:     return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
 912
 913                 default:
 914                         DE_ASSERT(false);
 915                         return VK_IMAGE_VIEW_TYPE_LAST;
 916         }
 917 }
 918
 919 std::string getImageTypeName (const ImageType imageType)
 920 {
 921         switch (imageType)
 922         {
 923                 case IMAGE_TYPE_1D:                     return "1d";
 924                 case IMAGE_TYPE_1D_ARRAY:       return "1d_array";
 925                 case IMAGE_TYPE_2D:                     return "2d";
 926                 case IMAGE_TYPE_2D_ARRAY:       return "2d_array";
 927                 case IMAGE_TYPE_3D:                     return "3d";
 928                 case IMAGE_TYPE_CUBE:           return "cube";
 929                 case IMAGE_TYPE_CUBE_ARRAY:     return "cube_array";
 930                 case IMAGE_TYPE_BUFFER:         return "buffer";
 931
 932                 default:
 933                         DE_ASSERT(false);
 934                         return "";
 935         }
 936 }
 937
 938 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample)
 939 {
 940         std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
 941                                                          tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER   ? "i" : "";
 942
 943         std::string imageTypePart;
 944         if (multisample)
 945         {
 946                 switch (imageType)
 947                 {
 948                         case IMAGE_TYPE_2D:                     imageTypePart = "2DMS";                 break;
 949                         case IMAGE_TYPE_2D_ARRAY:       imageTypePart = "2DMSArray";    break;
 950
 951                         default:
 952                                 DE_ASSERT(false);
 953                 }
 954         }
 955         else
 956         {
 957                 switch (imageType)
 958                 {
 959                         case IMAGE_TYPE_1D:                     imageTypePart = "1D";                   break;
 960                         case IMAGE_TYPE_1D_ARRAY:       imageTypePart = "1DArray";              break;
 961                         case IMAGE_TYPE_2D:                     imageTypePart = "2D";                   break;
 962                         case IMAGE_TYPE_2D_ARRAY:       imageTypePart = "2DArray";              break;
 963                         case IMAGE_TYPE_3D:                     imageTypePart = "3D";                   break;
 964                         case IMAGE_TYPE_CUBE:           imageTypePart = "Cube";                 break;
 965                         case IMAGE_TYPE_CUBE_ARRAY:     imageTypePart = "CubeArray";    break;
 966                         case IMAGE_TYPE_BUFFER:         imageTypePart = "Buffer";               break;
 967
 968                         default:
 969                                 DE_ASSERT(false);
 970                 }
 971         }
 972
 973         return formatPart + "image" + imageTypePart;
 974 }
 975
 976 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
 977 {
 978         const char* orderPart;
 979         const char* typePart;
 980
 981         switch (format.order)
 982         {
 983                 case tcu::TextureFormat::R:             orderPart = "r";        break;
 984                 case tcu::TextureFormat::RG:    orderPart = "rg";       break;
 985                 case tcu::TextureFormat::RGB:   orderPart = "rgb";      break;
 986                 case tcu::TextureFormat::RGBA:  orderPart = "rgba";     break;
 987
 988                 default:
 989                         DE_ASSERT(false);
 990                         orderPart = DE_NULL;
 991         }
 992
 993         switch (format.type)
 994         {
 995                 case tcu::TextureFormat::FLOAT:                         typePart = "32f";               break;
 996                 case tcu::TextureFormat::HALF_FLOAT:            typePart = "16f";               break;
 997
 998                 case tcu::TextureFormat::UNSIGNED_INT32:        typePart = "32ui";              break;
 999                 case tcu::TextureFormat::UNSIGNED_INT16:        typePart = "16ui";              break;
1000                 case tcu::TextureFormat::UNSIGNED_INT8:         typePart = "8ui";               break;
1001
1002                 case tcu::TextureFormat::SIGNED_INT32:          typePart = "32i";               break;
1003                 case tcu::TextureFormat::SIGNED_INT16:          typePart = "16i";               break;
1004                 case tcu::TextureFormat::SIGNED_INT8:           typePart = "8i";                break;
1005
1006                 case tcu::TextureFormat::UNORM_INT16:           typePart = "16";                break;
1007                 case tcu::TextureFormat::UNORM_INT8:            typePart = "8";                 break;
1008
1009                 case tcu::TextureFormat::SNORM_INT16:           typePart = "16_snorm";  break;
1010                 case tcu::TextureFormat::SNORM_INT8:            typePart = "8_snorm";   break;
1011
1012                 default:
1013                         DE_ASSERT(false);
1014                         typePart = DE_NULL;
1015         }
1016
1017         return std::string() + orderPart + typePart;
1018 }
1019
1020 std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
1021 {
1022         const char* typePart    = DE_NULL;
1023         const char* formatPart  = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
1024                                                           tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER   ? "i" : "";
1025
1026         switch (type)
1027         {
1028                 case VK_IMAGE_VIEW_TYPE_1D:                     typePart = "sampler1D";                 break;
1029                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:       typePart = "sampler1DArray";    break;
1030                 case VK_IMAGE_VIEW_TYPE_2D:                     typePart = "sampler2D";                 break;
1031                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:       typePart = "sampler2DArray";    break;
1032                 case VK_IMAGE_VIEW_TYPE_3D:                     typePart = "sampler3D";                 break;
1033                 case VK_IMAGE_VIEW_TYPE_CUBE:           typePart = "samplerCube";               break;
1034                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:     typePart = "samplerCubeArray";  break;
1035
1036                 default:
1037                         DE_FATAL("Unknown image view type");
1038                         break;
1039         }
1040
1041         return std::string(formatPart) + typePart;
1042 }
1043
1044
1045 const char* getGlslInputFormatType (const vk::VkFormat format)
1046 {
1047         switch (format)
1048         {
1049                 // 64-bit
1050                 case VK_FORMAT_R16G16B16A16_UNORM:              return "subpassInput";
1051                 case VK_FORMAT_R16G16B16A16_SNORM:              return "subpassInput";
1052                 case VK_FORMAT_R16G16B16A16_USCALED:    return "subpassInput";
1053                 case VK_FORMAT_R16G16B16A16_SSCALED:    return "subpassInput";
1054                 case VK_FORMAT_R16G16B16A16_UINT:               return "usubpassInput";
1055                 case VK_FORMAT_R16G16B16A16_SINT:               return "isubpassInput";
1056                 case VK_FORMAT_R16G16B16A16_SFLOAT:             return "subpassInput";
1057                 case VK_FORMAT_R32G32_UINT:                             return "usubpassInput";
1058                 case VK_FORMAT_R32G32_SINT:                             return "isubpassInput";
1059                 case VK_FORMAT_R32G32_SFLOAT:                   return "subpassInput";
1060                 // TODO: case VK_FORMAT_R64_UINT:               return "usubpassInput";
1061                 // TODO: case VK_FORMAT_R64_SINT:               return "isubpassInput";
1062                 // TODO: case VK_FORMAT_R64_SFLOAT:             return "subpassInput";
1063
1064                 // 128-bit
1065                 case VK_FORMAT_R32G32B32A32_UINT:               return "usubpassInput";
1066                 case VK_FORMAT_R32G32B32A32_SINT:               return "isubpassInput";
1067                 case VK_FORMAT_R32G32B32A32_SFLOAT:             return "subpassInput";
1068                 // TODO: case VK_FORMAT_R64G64_UINT:    return "usubpassInput";
1069                 // TODO: case VK_FORMAT_R64G64_SINT:    return "isubpassInput";
1070                 // TODO: case VK_FORMAT_R64G64_SFLOAT:  return "subpassInput";
1071
1072                 default:        TCU_THROW(InternalError, "Unknown format");
1073         }
1074 }
1075
1076 const char* getGlslFormatType (const vk::VkFormat format)
1077 {
1078         switch (format)
1079         {
1080                 // 64-bit
1081                 case VK_FORMAT_R16G16B16A16_UNORM:              return "vec4";
1082                 case VK_FORMAT_R16G16B16A16_SNORM:              return "vec4";
1083                 case VK_FORMAT_R16G16B16A16_USCALED:    return "vec4";
1084                 case VK_FORMAT_R16G16B16A16_SSCALED:    return "vec4";
1085                 case VK_FORMAT_R16G16B16A16_UINT:               return "uvec4";
1086                 case VK_FORMAT_R16G16B16A16_SINT:               return "ivec4";
1087                 case VK_FORMAT_R16G16B16A16_SFLOAT:             return "vec4";
1088                 case VK_FORMAT_R32G32_UINT:                             return "uvec2";
1089                 case VK_FORMAT_R32G32_SINT:                             return "ivec2";
1090                 case VK_FORMAT_R32G32_SFLOAT:                   return "vec2";
1091                 // TODO: case VK_FORMAT_R64_UINT:               return "uint64";
1092                 // TODO: case VK_FORMAT_R64_SINT:               return "int64";
1093                 // TODO: case VK_FORMAT_R64_SFLOAT:             return "double";
1094
1095                 // 128-bit
1096                 case VK_FORMAT_R32G32B32A32_UINT:               return "uvec4";
1097                 case VK_FORMAT_R32G32B32A32_SINT:               return "ivec4";
1098                 case VK_FORMAT_R32G32B32A32_SFLOAT:             return "vec4";
1099                 // TODO: case VK_FORMAT_R64G64_UINT:    return "ulvec2";
1100                 // TODO: case VK_FORMAT_R64G64_SINT:    return "ilvec2";
1101                 // TODO: case VK_FORMAT_R64G64_SFLOAT:  return "dvec2";
1102
1103                 default:        TCU_THROW(InternalError, "Unknown format");
1104         }
1105 }
1106
1107 std::string getFormatShortString (const VkFormat format)
1108 {
1109         const std::string fullName = getFormatName(format);
1110
1111         DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
1112
1113         return de::toLower(fullName.substr(10));
1114 }
1115
1116 std::vector<tcu::Vec4> createFullscreenQuad (void)
1117 {
1118         const tcu::Vec4 lowerLeftVertex         (-1.0f, -1.0f,  0.0f,   1.0f);
1119         const tcu::Vec4 upperLeftVertex         (-1.0f, 1.0f,   0.0f,   1.0f);
1120         const tcu::Vec4 lowerRightVertex        (1.0f,  -1.0f,  0.0f,   1.0f);
1121         const tcu::Vec4 upperRightVertex        (1.0f,  1.0f,   0.0f,   1.0f);
1122
1123         const tcu::Vec4 vertices[6] =
1124         {
1125                 lowerLeftVertex,
1126                 lowerRightVertex,
1127                 upperLeftVertex,
1128
1129                 upperLeftVertex,
1130                 lowerRightVertex,
1131                 upperRightVertex
1132         };
1133
1134         return std::vector<tcu::Vec4>(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices));
1135 }
1136
1137 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight)
1138 {
1139         const VkBufferImageCopy copyParams      =
1140         {
1141                 (VkDeviceSize)0u,                                               // bufferOffset
1142                 imageWidth,                                                             // bufferRowLength
1143                 imageHeight,                                                    // bufferImageHeight
1144                 {
1145                         VK_IMAGE_ASPECT_COLOR_BIT,                              // aspectMask
1146                         0u,                                                                             // mipLevel
1147                         0u,                                                                             // baseArrayLayer
1148                         1u,                                                                             // layerCount
1149                 },                                                                              // imageSubresource
1150                 { 0u, 0u, 0u },                                                 // imageOffset
1151                 {
1152                         imageWidth,
1153                         imageHeight,
1154                         1u
1155                 }                                                                               // imageExtent
1156         };
1157
1158         return copyParams;
1159 }
1160
1161 void beginRenderPass (const DeviceInterface&    vk,
1162                                           const VkCommandBuffer         commandBuffer,
1163                                           const VkRenderPass            renderPass,
1164                                           const VkFramebuffer           framebuffer,
1165                                           const VkExtent2D&                     renderSize)
1166 {
1167         const VkClearValue                      clearValues[]           =
1168         {
1169                 makeClearValueColorF32(0.0, 0.0, 0.0, 0.0),
1170                 makeClearValueColorF32(0.0, 0.0, 0.0, 0.0),
1171         };
1172         const VkRect2D                          renderArea                      =
1173         {
1174                 {0, 0},                                                                                 // VkOffset2D                           offset;
1175                 renderSize,                                                                             // VkExtent2D                           extent;
1176         };
1177         const VkRenderPassBeginInfo     renderPassBeginInfo =
1178         {
1179                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,               // VkStructureType                      sType;
1180                 DE_NULL,                                                                                // const void*                          pNext;
1181                 renderPass,                                                                             // VkRenderPass                         renderPass;
1182                 framebuffer,                                                                    // VkFramebuffer                        framebuffer;
1183                 renderArea,                                                                             // VkRect2D                                     renderArea;
1184                 DE_LENGTH_OF_ARRAY(clearValues),                                // uint32_t                                     clearValueCount;
1185                 clearValues,                                                                    // const VkClearValue*          pClearValues;
1186         };
1187
1188         vk.cmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
1189 }
1190
1191 Move<VkFramebuffer> makeFramebuffer (const DeviceInterface&     vk,
1192                                                                          const VkDevice                 device,
1193                                                                          const VkRenderPass             renderPass,
1194                                                                          const deUint32                 attachmentCount,
1195                                                                          const VkImageView*             pAttachments,
1196                                                                          const VkExtent2D&              size,
1197                                                                          const deUint32                 layersCount)
1198 {
1199         const vk::VkFramebufferCreateInfo framebufferInfo =
1200         {
1201                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,              // VkStructureType                      sType;
1202                 DE_NULL,                                                                                // const void*                          pNext;
1203                 (VkFramebufferCreateFlags)0,                                    // VkFramebufferCreateFlags     flags;
1204                 renderPass,                                                                             // VkRenderPass                         renderPass;
1205                 attachmentCount,                                                                // uint32_t                                     attachmentCount;
1206                 pAttachments,                                                                   // const VkImageView*           pAttachments;
1207                 static_cast<deUint32>(size.width),                              // uint32_t                                     width;
1208                 static_cast<deUint32>(size.height),                             // uint32_t                                     height;
1209                 layersCount,                                                                    // uint32_t                                     layers;
1210         };
1211
1212         return createFramebuffer(vk, device, &framebufferInfo);
1213 }
1214
1215
1216 } // image
1217 } // vkt