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 "vkCmdUtil.hpp"
  28 #include "vkObjUtil.hpp"
  29 #include "tcuTextureUtil.hpp"
  30
  31 using namespace vk;
  32
  33 namespace vkt
  34 {
  35 namespace image
  36 {
  37
  38 Buffer::Buffer (const DeviceInterface&          vk,
  39                                 const VkDevice                          device,
  40                                 Allocator&                                      allocator,
  41                                 const VkBufferCreateInfo&       bufferCreateInfo,
  42                                 const MemoryRequirement         memoryRequirement)
  43 {
  44         m_buffer = createBuffer(vk, device, &bufferCreateInfo);
  45         m_allocation = allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), memoryRequirement);
  46         VK_CHECK(vk.bindBufferMemory(device, *m_buffer, m_allocation->getMemory(), m_allocation->getOffset()));
  47 }
  48
  49 Image::Image (const DeviceInterface&    vk,
  50                           const VkDevice                        device,
  51                           Allocator&                            allocator,
  52                           const VkImageCreateInfo&      imageCreateInfo,
  53                           const MemoryRequirement       memoryRequirement)
  54 {
  55         m_image = createImage(vk, device, &imageCreateInfo);
  56         de::SharedPtr<vk::Allocation> allocation(allocator.allocate(getImageMemoryRequirements(vk, device, *m_image), memoryRequirement).release());
  57         m_allocations.push_back(allocation);
  58         VK_CHECK(vk.bindImageMemory(device, *m_image, allocation->getMemory(), allocation->getOffset()));
  59 }
  60
  61 Image::Image (void)
  62         : m_allocations ()
  63         , m_image               ()
  64 {}
  65
  66 SparseImage::SparseImage (const vk::DeviceInterface&    vkd,
  67                                                   vk::VkDevice                                  device,
  68                                                   vk::VkPhysicalDevice                  physicalDevice,
  69                                                   const vk::InstanceInterface&  vki,
  70                                                   const vk::VkImageCreateInfo&  createInfo,
  71                                                   const vk::VkQueue                             sparseQueue,
  72                                                   vk::Allocator&                                allocator,
  73                                                   const tcu::TextureFormat&             format)
  74         : Image                 ()
  75         , m_semaphore   ()
  76 {
  77         m_image         = createImage(vkd, device, &createInfo);
  78         m_semaphore     = createSemaphore(vkd, device);
  79         allocateAndBindSparseImage(vkd, device, physicalDevice, vki, createInfo, m_semaphore.get(), sparseQueue, allocator, m_allocations, format, m_image.get());
  80 }
  81
  82 tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize)
  83 {
  84         switch (imageType)
  85         {
  86                 case IMAGE_TYPE_1D:
  87                 case IMAGE_TYPE_BUFFER:
  88                         return tcu::UVec3(imageSize.x(), 1u, 1u);
  89
  90                 case IMAGE_TYPE_1D_ARRAY:
  91                         return tcu::UVec3(imageSize.x(), imageSize.z(), 1u);
  92
  93                 case IMAGE_TYPE_2D:
  94                         return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
  95
  96                 case IMAGE_TYPE_2D_ARRAY:
  97                 case IMAGE_TYPE_3D:
  98                         return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
  99
 100                 case IMAGE_TYPE_CUBE:
 101                         return tcu::UVec3(imageSize.x(), imageSize.y(), 6u);
 102
 103                 case IMAGE_TYPE_CUBE_ARRAY:
 104                         return tcu::UVec3(imageSize.x(), imageSize.y(), 6u * imageSize.z());
 105
 106                 default:
 107                         DE_FATAL("Unknown image type");
 108                         return tcu::UVec3(1u, 1u, 1u);
 109         }
 110 }
 111
 112 tcu::UVec3 getLayerSize (const ImageType imageType, const tcu::UVec3& imageSize)
 113 {
 114         switch (imageType)
 115         {
 116                 case IMAGE_TYPE_1D:
 117                 case IMAGE_TYPE_1D_ARRAY:
 118                 case IMAGE_TYPE_BUFFER:
 119                         return tcu::UVec3(imageSize.x(), 1u, 1u);
 120
 121                 case IMAGE_TYPE_2D:
 122                 case IMAGE_TYPE_2D_ARRAY:
 123                 case IMAGE_TYPE_CUBE:
 124                 case IMAGE_TYPE_CUBE_ARRAY:
 125                         return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
 126
 127                 case IMAGE_TYPE_3D:
 128                         return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
 129
 130                 default:
 131                         DE_FATAL("Unknown image type");
 132                         return tcu::UVec3(1u, 1u, 1u);
 133         }
 134 }
 135
 136 deUint32 getNumLayers (const ImageType imageType, const tcu::UVec3& imageSize)
 137 {
 138         switch (imageType)
 139         {
 140                 case IMAGE_TYPE_1D:
 141                 case IMAGE_TYPE_2D:
 142                 case IMAGE_TYPE_3D:
 143                 case IMAGE_TYPE_BUFFER:
 144                         return 1u;
 145
 146                 case IMAGE_TYPE_1D_ARRAY:
 147                 case IMAGE_TYPE_2D_ARRAY:
 148                         return imageSize.z();
 149
 150                 case IMAGE_TYPE_CUBE:
 151                         return 6u;
 152
 153                 case IMAGE_TYPE_CUBE_ARRAY:
 154                         return imageSize.z() * 6u;
 155
 156                 default:
 157                         DE_FATAL("Unknown image type");
 158                         return 0u;
 159         }
 160 }
 161
 162 deUint32 getNumPixels (const ImageType imageType, const tcu::UVec3& imageSize)
 163 {
 164         const tcu::UVec3 gridSize = getShaderGridSize(imageType, imageSize);
 165
 166         return gridSize.x() * gridSize.y() * gridSize.z();
 167 }
 168
 169 deUint32 getDimensions (const ImageType imageType)
 170 {
 171         switch (imageType)
 172         {
 173                 case IMAGE_TYPE_1D:
 174                 case IMAGE_TYPE_BUFFER:
 175                         return 1u;
 176
 177                 case IMAGE_TYPE_1D_ARRAY:
 178                 case IMAGE_TYPE_2D:
 179                         return 2u;
 180
 181                 case IMAGE_TYPE_2D_ARRAY:
 182                 case IMAGE_TYPE_CUBE:
 183                 case IMAGE_TYPE_CUBE_ARRAY:
 184                 case IMAGE_TYPE_3D:
 185                         return 3u;
 186
 187                 default:
 188                         DE_FATAL("Unknown image type");
 189                         return 0u;
 190         }
 191 }
 192
 193 deUint32 getLayerDimensions (const ImageType imageType)
 194 {
 195         switch (imageType)
 196         {
 197                 case IMAGE_TYPE_1D:
 198                 case IMAGE_TYPE_BUFFER:
 199                 case IMAGE_TYPE_1D_ARRAY:
 200                         return 1u;
 201
 202                 case IMAGE_TYPE_2D:
 203                 case IMAGE_TYPE_2D_ARRAY:
 204                 case IMAGE_TYPE_CUBE:
 205                 case IMAGE_TYPE_CUBE_ARRAY:
 206                         return 2u;
 207
 208                 case IMAGE_TYPE_3D:
 209                         return 3u;
 210
 211                 default:
 212                         DE_FATAL("Unknown image type");
 213                         return 0u;
 214         }
 215 }
 216
 217 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
 218                                                                            const deUint32       arraySize)
 219 {
 220         const VkBufferImageCopy copyParams =
 221         {
 222                 0ull,                                                                                                                                           //      VkDeviceSize                            bufferOffset;
 223                 0u,                                                                                                                                                     //      deUint32                                        bufferRowLength;
 224                 0u,                                                                                                                                                     //      deUint32                                        bufferImageHeight;
 225                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize),       //      VkImageSubresourceLayers        imageSubresource;
 226                 makeOffset3D(0, 0, 0),                                                                                                          //      VkOffset3D                                      imageOffset;
 227                 extent,                                                                                                                                         //      VkExtent3D                                      imageExtent;
 228         };
 229         return copyParams;
 230 }
 231
 232 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface&   vk,
 233                                                                            const VkDevice                       device,
 234                                                                            const VkPipelineLayout       pipelineLayout,
 235                                                                            const VkRenderPass           renderPass,
 236                                                                            const VkShaderModule         vertexModule,
 237                                                                            const VkShaderModule         fragmentModule,
 238                                                                            const VkExtent2D                     renderSize,
 239                                                                            const deUint32                       colorAttachmentCount,
 240                                                                            const bool                           dynamicSize)
 241 {
 242         std::vector<VkViewport>                                                         viewports;
 243         std::vector<VkRect2D>                                                           scissors;
 244
 245         const VkViewport                                                                        viewport                                                = makeViewport(renderSize);
 246         const VkRect2D                                                                          scissor                                                 = makeRect2D(renderSize);
 247
 248         const VkFormat                                                                          vertexFormatPosition                    = VK_FORMAT_R32G32B32A32_SFLOAT;
 249         const deUint32                                                                          vertexSizePosition                              = tcu::getPixelSize(mapVkFormat(vertexFormatPosition));
 250         const deUint32                                                                          vertexBufferOffsetPosition              = 0u;
 251         const deUint32                                                                          vertexDataStride                                = vertexSizePosition;
 252
 253         if (!dynamicSize)
 254         {
 255                 viewports.push_back(viewport);
 256                 scissors.push_back(scissor);
 257         }
 258
 259         const VkVertexInputBindingDescription                           vertexInputBindingDescription   =
 260         {
 261                 0u,                                                     // deUint32             binding;
 262                 vertexDataStride,                       // deUint32             stride;
 263                 VK_VERTEX_INPUT_RATE_VERTEX     // VkVertexInputRate    inputRate;
 264         };
 265
 266         const VkVertexInputAttributeDescription                         vertexInputAttributeDescription =
 267         {
 268                 0u,                                                     // deUint32    location;
 269                 0u,                                                     // deUint32    binding;
 270                 vertexFormatPosition,           // VkFormat    format;
 271                 vertexBufferOffsetPosition,     // deUint32    offset;
 272         };
 273
 274         const VkPipelineVertexInputStateCreateInfo                      vertexInputStateCreateInfo              =
 275         {
 276                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      // VkStructureType                             sType;
 277                 DE_NULL,                                                                                                        // const void*                                 pNext;
 278                 (VkPipelineVertexInputStateCreateFlags)0,                                       // VkPipelineVertexInputStateCreateFlags       flags;
 279                 1u,                                                                                                                     // deUint32                                    vertexBindingDescriptionCount;
 280                 &vertexInputBindingDescription,                                                         // const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
 281                 1u,                                                                                                                     // deUint32                                    vertexAttributeDescriptionCount;
 282                 &vertexInputAttributeDescription                                                        // const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
 283         };
 284
 285         const VkColorComponentFlags                                                     colorComponentsAll                              = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 286         const VkPipelineColorBlendAttachmentState                       colorBlendAttachmentState               =
 287         {
 288                 VK_FALSE,                               // VkBool32                 blendEnable;
 289                 VK_BLEND_FACTOR_ONE,    // VkBlendFactor            srcColorBlendFactor;
 290                 VK_BLEND_FACTOR_ZERO,   // VkBlendFactor            dstColorBlendFactor;
 291                 VK_BLEND_OP_ADD,                // VkBlendOp                colorBlendOp;
 292                 VK_BLEND_FACTOR_ONE,    // VkBlendFactor            srcAlphaBlendFactor;
 293                 VK_BLEND_FACTOR_ZERO,   // VkBlendFactor            dstAlphaBlendFactor;
 294                 VK_BLEND_OP_ADD,                // VkBlendOp                alphaBlendOp;
 295                 colorComponentsAll              // VkColorComponentFlags    colorWriteMask;
 296         };
 297
 298         std::vector<VkPipelineColorBlendAttachmentState>        colorAttachments                                (colorAttachmentCount, colorBlendAttachmentState);
 299
 300         const VkPipelineColorBlendStateCreateInfo                       pipelineColorBlendStateInfo             =
 301         {
 302                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,               // VkStructureType                              sType;
 303                 DE_NULL,                                                                                                                // const void*                                  pNext;
 304                 (VkPipelineColorBlendStateCreateFlags)0,                                                // VkPipelineColorBlendStateCreateFlags         flags;
 305                 VK_FALSE,                                                                                                               // VkBool32                                     logicOpEnable;
 306                 VK_LOGIC_OP_COPY,                                                                                               // VkLogicOp                                    logicOp;
 307                 (deUint32)colorAttachments.size(),                                                              // deUint32                                     attachmentCount;
 308                 colorAttachments.size() != 0 ? &colorAttachments[0] : DE_NULL,  // const VkPipelineColorBlendAttachmentState*   pAttachments;
 309                 { 0.0f, 0.0f, 0.0f, 0.0f }                                                                              // float                                        blendConstants[4];
 310         };
 311
 312         return vk::makeGraphicsPipeline(vk,                                                                             // const DeviceInterface&                        vk
 313                                                                         device,                                                                 // const VkDevice                                device
 314                                                                         pipelineLayout,                                                 // const VkPipelineLayout                        pipelineLayout
 315                                                                         vertexModule,                                                   // const VkShaderModule                          vertexShaderModule
 316                                                                         DE_NULL,                                                                // const VkShaderModule                          tessellationControlModule
 317                                                                         DE_NULL,                                                                // const VkShaderModule                          tessellationEvalModule
 318                                                                         DE_NULL,                                                                // const VkShaderModule                          geometryShaderModule
 319                                                                         fragmentModule,                                                 // const VkShaderModule                          fragmentShaderModule
 320                                                                         renderPass,                                                             // const VkRenderPass                            renderPass
 321                                                                         viewports,                                                              // const std::vector<VkViewport>&                viewports
 322                                                                         scissors,                                                               // const std::vector<VkRect2D>&                  scissors
 323                                                                         VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,    // const VkPrimitiveTopology                     topology
 324                                                                         0u,                                                                             // const deUint32                                subpass
 325                                                                         0u,                                                                             // const deUint32                                patchControlPoints
 326                                                                         &vertexInputStateCreateInfo,                    // const VkPipelineVertexInputStateCreateInfo*   vertexInputStateCreateInfo
 327                                                                         DE_NULL,                                                                // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
 328                                                                         DE_NULL,                                                                // const VkPipelineMultisampleStateCreateInfo*   multisampleStateCreateInfo
 329                                                                         DE_NULL,                                                                // const VkPipelineDepthStencilStateCreateInfo*  depthStencilStateCreateInfo
 330                                                                         &pipelineColorBlendStateInfo);                  // const VkPipelineColorBlendStateCreateInfo*    colorBlendStateCreateInfo
 331 }
 332
 333 //! A single-subpass render pass.
 334 Move<VkRenderPass> makeRenderPass (const DeviceInterface&       vk,
 335                                                                    const VkDevice                       device,
 336                                                                    const VkFormat                       inputFormat,
 337                                                                    const VkFormat                       colorFormat)
 338 {
 339         const VkAttachmentReference             inputAttachmentRef                      =
 340         {
 341                 0u,                                                                                                                     // deUint32                     attachment;
 342                 VK_IMAGE_LAYOUT_GENERAL                                                                         // VkImageLayout        layout;
 343         };
 344
 345         const VkAttachmentReference             colorAttachmentRef                      =
 346         {
 347                 1u,                                                                                                                     // deUint32                     attachment;
 348                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                                        // VkImageLayout        layout;
 349         };
 350
 351         const VkSubpassDescription              subpassDescription                      =
 352         {
 353                 (VkSubpassDescriptionFlags)0,                                                           // VkSubpassDescriptionFlags            flags;
 354                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                                        // VkPipelineBindPoint                          pipelineBindPoint;
 355                 1u,                                                                                                                     // deUint32                                                     inputAttachmentCount;
 356                 &inputAttachmentRef,                                                                            // const VkAttachmentReference*         pInputAttachments;
 357                 1u,                                                                                                                     // deUint32                                                     colorAttachmentCount;
 358                 &colorAttachmentRef,                                                                            // const VkAttachmentReference*         pColorAttachments;
 359                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pResolveAttachments;
 360                 DE_NULL,                                                                                                        // const VkAttachmentReference*         pDepthStencilAttachment;
 361                 0u,                                                                                                                     // deUint32                                                     preserveAttachmentCount;
 362                 DE_NULL                                                                                                         // const deUint32*                                      pPreserveAttachments;
 363         };
 364
 365         const VkAttachmentDescription   attachmentsDescriptions[]       =
 366         {
 367                 //inputAttachmentDescription,
 368                 {
 369                         (VkAttachmentDescriptionFlags)0,                                                // VkAttachmentDescriptionFlags         flags;
 370                         inputFormat,                                                                                    // VkFormat                                                     format;
 371                         VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits                        samples;
 372                         VK_ATTACHMENT_LOAD_OP_LOAD,                                                             // VkAttachmentLoadOp                           loadOp;
 373                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                                               // VkAttachmentStoreOp                          storeOp;
 374                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                                // VkAttachmentLoadOp                           stencilLoadOp;
 375                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                                               // VkAttachmentStoreOp                          stencilStoreOp;
 376                         VK_IMAGE_LAYOUT_GENERAL,                                                                // VkImageLayout                                        initialLayout;
 377                         VK_IMAGE_LAYOUT_GENERAL,                                                                // VkImageLayout                                        finalLayout;
 378                 },
 379                 //colorAttachmentDescription
 380                 {
 381                         (VkAttachmentDescriptionFlags)0,                                                // VkAttachmentDescriptionFlags         flags;
 382                         colorFormat,                                                                                    // VkFormat                                                     format;
 383                         VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits                        samples;
 384                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                                    // VkAttachmentLoadOp                           loadOp;
 385                         VK_ATTACHMENT_STORE_OP_STORE,                                                   // VkAttachmentStoreOp                          storeOp;
 386                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                                // VkAttachmentLoadOp                           stencilLoadOp;
 387                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                                               // VkAttachmentStoreOp                          stencilStoreOp;
 388                         VK_IMAGE_LAYOUT_UNDEFINED,                                                              // VkImageLayout                                        initialLayout;
 389                         VK_IMAGE_LAYOUT_GENERAL,                                                                // VkImageLayout                                        finalLayout;
 390                 }
 391         };
 392
 393         const VkRenderPassCreateInfo    renderPassInfo                          =
 394         {
 395                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                                      // VkStructureType                                      sType;
 396                 DE_NULL,                                                                                                        // const void*                                          pNext;
 397                 (VkRenderPassCreateFlags)0,                                                                     // VkRenderPassCreateFlags                      flags;
 398                 DE_LENGTH_OF_ARRAY(attachmentsDescriptions),                            // deUint32                                                     attachmentCount;
 399                 attachmentsDescriptions,                                                                        // const VkAttachmentDescription*       pAttachments;
 400                 1u,                                                                                                                     // deUint32                                                     subpassCount;
 401                 &subpassDescription,                                                                            // const VkSubpassDescription*          pSubpasses;
 402                 0u,                                                                                                                     // deUint32                                                     dependencyCount;
 403                 DE_NULL                                                                                                         // const VkSubpassDependency*           pDependencies;
 404         };
 405
 406         return createRenderPass(vk, device, &renderPassInfo);
 407 }
 408
 409 VkImageViewUsageCreateInfo makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags)
 410 {
 411         VkImageViewUsageCreateInfo imageViewUsageCreateInfo =
 412         {
 413                 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,     //VkStructureType               sType;
 414                 DE_NULL,                                                                                        //const void*                   pNext;
 415                 imageUsageFlags,                                                                        //VkImageUsageFlags             usage;
 416         };
 417
 418         return imageViewUsageCreateInfo;
 419 }
 420
 421 VkSamplerCreateInfo makeSamplerCreateInfo ()
 422 {
 423         const VkSamplerCreateInfo defaultSamplerParams =
 424         {
 425                 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,          // VkStructureType                      sType;
 426                 DE_NULL,                                                                        // const void*                          pNext;
 427                 0u,                                                                                     // VkSamplerCreateFlags         flags;
 428                 VK_FILTER_NEAREST,                                                      // VkFilter                                     magFilter;
 429                 VK_FILTER_NEAREST,                                                      // VkFilter                                     minFilter;
 430                 VK_SAMPLER_MIPMAP_MODE_NEAREST,                         // VkSamplerMipmapMode          mipmapMode;
 431                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // VkSamplerAddressMode         addressModeU;
 432                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // VkSamplerAddressMode         addressModeV;
 433                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          // VkSamplerAddressMode         addressModeW;
 434                 0.0f,                                                                           // float                                        mipLodBias;
 435                 VK_FALSE,                                                                       // VkBool32                                     anisotropyEnable;
 436                 1.0f,                                                                           // float                                        maxAnisotropy;
 437                 VK_FALSE,                                                                       // VkBool32                                     compareEnable;
 438                 VK_COMPARE_OP_NEVER,                                            // VkCompareOp                          compareOp;
 439                 0.0f,                                                                           // float                                        minLod;
 440                 0.25f,                                                                          // float                                        maxLod;
 441                 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,        // VkBorderColor                        borderColor;
 442                 VK_FALSE                                                                        // VkBool32                                     unnormalizedCoordinates;
 443         };
 444
 445         return defaultSamplerParams;
 446 }
 447
 448 tcu::UVec3 getCompressedImageResolutionInBlocks (const vk::VkFormat format, const tcu::UVec3& size)
 449 {
 450         deUint32        blockWidth      = getBlockWidth(format);
 451         deUint32        blockHeight     = getBlockHeight(format);
 452
 453         DE_ASSERT(size[2] == 1);
 454         DE_ASSERT(blockWidth != 0 && blockHeight != 0);
 455
 456         deUint32        widthInBlocks   = (size[0] + blockWidth - 1) / blockWidth;
 457         deUint32        heightInBlocks  = (size[1] + blockHeight - 1) / blockHeight;
 458
 459         return tcu::UVec3(widthInBlocks, heightInBlocks, 1);
 460 }
 461
 462 tcu::UVec3 getCompressedImageResolutionBlockCeil (const vk::VkFormat format, const tcu::UVec3& size)
 463 {
 464         deUint32        blockWidth      = getBlockWidth(format);
 465         deUint32        blockHeight     = getBlockHeight(format);
 466
 467         DE_ASSERT(size[2] == 1);
 468         DE_ASSERT(blockWidth != 0 && blockHeight != 0);
 469
 470         deUint32        widthInBlocks   = (size[0] + blockWidth - 1) / blockWidth;
 471         deUint32        heightInBlocks  = (size[1] + blockHeight - 1) / blockHeight;
 472
 473         return tcu::UVec3(blockWidth * widthInBlocks, blockHeight * heightInBlocks, 1);
 474 }
 475
 476 VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
 477 {
 478         tcu::UVec3              sizeInBlocks    = getCompressedImageResolutionInBlocks(format, size);
 479         deUint32                blockBytes              = getBlockSizeInBytes(format);
 480         VkDeviceSize    sizeBytes               = sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes;
 481
 482         return sizeBytes;
 483 }
 484
 485 VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
 486 {
 487         const tcu::IVec3        sizeAsIVec3     = tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z());
 488         const VkDeviceSize      sizeBytes       = getImageSizeBytes(sizeAsIVec3, format);
 489
 490         return sizeBytes;
 491 }
 492
 493 VkImageType     mapImageType (const ImageType imageType)
 494 {
 495         switch (imageType)
 496         {
 497                 case IMAGE_TYPE_1D:
 498                 case IMAGE_TYPE_1D_ARRAY:
 499                 case IMAGE_TYPE_BUFFER:
 500                         return VK_IMAGE_TYPE_1D;
 501
 502                 case IMAGE_TYPE_2D:
 503                 case IMAGE_TYPE_2D_ARRAY:
 504                 case IMAGE_TYPE_CUBE:
 505                 case IMAGE_TYPE_CUBE_ARRAY:
 506                         return VK_IMAGE_TYPE_2D;
 507
 508                 case IMAGE_TYPE_3D:
 509                         return VK_IMAGE_TYPE_3D;
 510
 511                 default:
 512                         DE_ASSERT(false);
 513                         return VK_IMAGE_TYPE_LAST;
 514         }
 515 }
 516
 517 VkImageViewType mapImageViewType (const ImageType imageType)
 518 {
 519         switch (imageType)
 520         {
 521                 case IMAGE_TYPE_1D:                     return VK_IMAGE_VIEW_TYPE_1D;
 522                 case IMAGE_TYPE_1D_ARRAY:       return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
 523                 case IMAGE_TYPE_2D:                     return VK_IMAGE_VIEW_TYPE_2D;
 524                 case IMAGE_TYPE_2D_ARRAY:       return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 525                 case IMAGE_TYPE_3D:                     return VK_IMAGE_VIEW_TYPE_3D;
 526                 case IMAGE_TYPE_CUBE:           return VK_IMAGE_VIEW_TYPE_CUBE;
 527                 case IMAGE_TYPE_CUBE_ARRAY:     return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
 528
 529                 default:
 530                         DE_ASSERT(false);
 531                         return VK_IMAGE_VIEW_TYPE_LAST;
 532         }
 533 }
 534
 535 std::string getImageTypeName (const ImageType imageType)
 536 {
 537         switch (imageType)
 538         {
 539                 case IMAGE_TYPE_1D:                     return "1d";
 540                 case IMAGE_TYPE_1D_ARRAY:       return "1d_array";
 541                 case IMAGE_TYPE_2D:                     return "2d";
 542                 case IMAGE_TYPE_2D_ARRAY:       return "2d_array";
 543                 case IMAGE_TYPE_3D:                     return "3d";
 544                 case IMAGE_TYPE_CUBE:           return "cube";
 545                 case IMAGE_TYPE_CUBE_ARRAY:     return "cube_array";
 546                 case IMAGE_TYPE_BUFFER:         return "buffer";
 547
 548                 default:
 549                         DE_ASSERT(false);
 550                         return "";
 551         }
 552 }
 553
 554 std::string getFormatPrefix (const tcu::TextureFormat& format)
 555 {
 556         const std::string image64 = ((mapTextureFormat(format) == VK_FORMAT_R64_UINT || mapTextureFormat(format) == VK_FORMAT_R64_SINT) ? "64" : "");
 557         return tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" + image64 :
 558                    tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER   ? "i" + image64 : "";
 559 }
 560
 561 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample)
 562 {
 563         std::string formatPart = getFormatPrefix(format);
 564
 565         std::string imageTypePart;
 566         if (multisample)
 567         {
 568                 switch (imageType)
 569                 {
 570                         case IMAGE_TYPE_2D:                     imageTypePart = "2DMS";                 break;
 571                         case IMAGE_TYPE_2D_ARRAY:       imageTypePart = "2DMSArray";    break;
 572
 573                         default:
 574                                 DE_ASSERT(false);
 575                 }
 576         }
 577         else
 578         {
 579                 switch (imageType)
 580                 {
 581                         case IMAGE_TYPE_1D:                     imageTypePart = "1D";                   break;
 582                         case IMAGE_TYPE_1D_ARRAY:       imageTypePart = "1DArray";              break;
 583                         case IMAGE_TYPE_2D:                     imageTypePart = "2D";                   break;
 584                         case IMAGE_TYPE_2D_ARRAY:       imageTypePart = "2DArray";              break;
 585                         case IMAGE_TYPE_3D:                     imageTypePart = "3D";                   break;
 586                         case IMAGE_TYPE_CUBE:           imageTypePart = "Cube";                 break;
 587                         case IMAGE_TYPE_CUBE_ARRAY:     imageTypePart = "CubeArray";    break;
 588                         case IMAGE_TYPE_BUFFER:         imageTypePart = "Buffer";               break;
 589
 590                         default:
 591                                 DE_ASSERT(false);
 592                 }
 593         }
 594
 595         return formatPart + "image" + imageTypePart;
 596 }
 597
 598 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
 599 {
 600         if (!isPackedType(mapTextureFormat(format)))
 601         {
 602                 const char* orderPart;
 603                 const char* typePart;
 604
 605                 switch (format.order)
 606                 {
 607                         case tcu::TextureFormat::R:             orderPart = "r";        break;
 608                         case tcu::TextureFormat::RG:    orderPart = "rg";       break;
 609                         case tcu::TextureFormat::RGB:   orderPart = "rgb";      break;
 610                         case tcu::TextureFormat::RGBA:  orderPart = "rgba";     break;
 611                         case tcu::TextureFormat::sRGBA: orderPart = "rgba";     break;
 612
 613                         default:
 614                                 DE_FATAL("Order not found");
 615                                 orderPart = DE_NULL;
 616                 }
 617
 618                 switch (format.type)
 619                 {
 620                         case tcu::TextureFormat::FLOAT:                         typePart = "32f";               break;
 621                         case tcu::TextureFormat::HALF_FLOAT:            typePart = "16f";               break;
 622
 623                         case tcu::TextureFormat::UNSIGNED_INT64:        typePart = "64ui";              break;
 624                         case tcu::TextureFormat::UNSIGNED_INT32:        typePart = "32ui";              break;
 625                         case tcu::TextureFormat::USCALED_INT16:
 626                         case tcu::TextureFormat::UNSIGNED_INT16:        typePart = "16ui";              break;
 627                         case tcu::TextureFormat::USCALED_INT8:
 628                         case tcu::TextureFormat::UNSIGNED_INT8:         typePart = "8ui";               break;
 629
 630                         case tcu::TextureFormat::SIGNED_INT64:          typePart = "64i";               break;
 631                         case tcu::TextureFormat::SIGNED_INT32:          typePart = "32i";               break;
 632                         case tcu::TextureFormat::SSCALED_INT16:
 633                         case tcu::TextureFormat::SIGNED_INT16:          typePart = "16i";               break;
 634                         case tcu::TextureFormat::SSCALED_INT8:
 635                         case tcu::TextureFormat::SIGNED_INT8:           typePart = "8i";                break;
 636
 637                         case tcu::TextureFormat::UNORM_INT16:           typePart = "16";                break;
 638                         case tcu::TextureFormat::UNORM_INT8:            typePart = "8";                 break;
 639
 640                         case tcu::TextureFormat::SNORM_INT16:           typePart = "16_snorm";  break;
 641                         case tcu::TextureFormat::SNORM_INT8:            typePart = "8_snorm";   break;
 642
 643                         default:
 644                                 DE_FATAL("Type not found");
 645                                 typePart = DE_NULL;
 646                 }
 647
 648                 return std::string() + orderPart + typePart;
 649         }
 650         else
 651         {
 652                 switch (mapTextureFormat(format))
 653                 {
 654                         case VK_FORMAT_B10G11R11_UFLOAT_PACK32:         return "r11f_g11f_b10f";
 655                         case VK_FORMAT_A2B10G10R10_UNORM_PACK32:        return "rgb10_a2";
 656                         case VK_FORMAT_A2B10G10R10_UINT_PACK32:         return "rgb10_a2ui";
 657
 658                         default:
 659                                 DE_FATAL("Qualifier not found");
 660                                 return "";
 661                 }
 662         }
 663 }
 664
 665 std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
 666 {
 667         const char* typePart    = DE_NULL;
 668         const char* formatPart  = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
 669                                                           tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER   ? "i" : "";
 670
 671         switch (type)
 672         {
 673                 case VK_IMAGE_VIEW_TYPE_1D:                     typePart = "sampler1D";                 break;
 674                 case VK_IMAGE_VIEW_TYPE_1D_ARRAY:       typePart = "sampler1DArray";    break;
 675                 case VK_IMAGE_VIEW_TYPE_2D:                     typePart = "sampler2D";                 break;
 676                 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:       typePart = "sampler2DArray";    break;
 677                 case VK_IMAGE_VIEW_TYPE_3D:                     typePart = "sampler3D";                 break;
 678                 case VK_IMAGE_VIEW_TYPE_CUBE:           typePart = "samplerCube";               break;
 679                 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:     typePart = "samplerCubeArray";  break;
 680
 681                 default:
 682                         DE_FATAL("Unknown image view type");
 683                         break;
 684         }
 685
 686         return std::string(formatPart) + typePart;
 687 }
 688
 689
 690 const char* getGlslInputFormatType (const vk::VkFormat format)
 691 {
 692         switch (format)
 693         {
 694                 // 64-bit
 695                 case VK_FORMAT_R16G16B16A16_UNORM:              return "subpassInput";
 696                 case VK_FORMAT_R16G16B16A16_SNORM:              return "subpassInput";
 697                 case VK_FORMAT_R16G16B16A16_USCALED:    return "subpassInput";
 698                 case VK_FORMAT_R16G16B16A16_SSCALED:    return "subpassInput";
 699                 case VK_FORMAT_R16G16B16A16_UINT:               return "usubpassInput";
 700                 case VK_FORMAT_R16G16B16A16_SINT:               return "isubpassInput";
 701                 case VK_FORMAT_R16G16B16A16_SFLOAT:             return "subpassInput";
 702                 case VK_FORMAT_R32G32_UINT:                             return "usubpassInput";
 703                 case VK_FORMAT_R32G32_SINT:                             return "isubpassInput";
 704                 case VK_FORMAT_R32G32_SFLOAT:                   return "subpassInput";
 705                 // TODO: case VK_FORMAT_R64_UINT:               return "usubpassInput";
 706                 // TODO: case VK_FORMAT_R64_SINT:               return "isubpassInput";
 707                 // TODO: case VK_FORMAT_R64_SFLOAT:             return "subpassInput";
 708
 709                 // 128-bit
 710                 case VK_FORMAT_R32G32B32A32_UINT:               return "usubpassInput";
 711                 case VK_FORMAT_R32G32B32A32_SINT:               return "isubpassInput";
 712                 case VK_FORMAT_R32G32B32A32_SFLOAT:             return "subpassInput";
 713                 // TODO: case VK_FORMAT_R64G64_UINT:    return "usubpassInput";
 714                 // TODO: case VK_FORMAT_R64G64_SINT:    return "isubpassInput";
 715                 // TODO: case VK_FORMAT_R64G64_SFLOAT:  return "subpassInput";
 716
 717                 default:        TCU_THROW(InternalError, "Unknown format");
 718         }
 719 }
 720
 721 const char* getGlslFormatType (const vk::VkFormat format)
 722 {
 723         switch (format)
 724         {
 725                 // 64-bit
 726                 case VK_FORMAT_R16G16B16A16_UNORM:              return "vec4";
 727                 case VK_FORMAT_R16G16B16A16_SNORM:              return "vec4";
 728                 case VK_FORMAT_R16G16B16A16_USCALED:    return "vec4";
 729                 case VK_FORMAT_R16G16B16A16_SSCALED:    return "vec4";
 730                 case VK_FORMAT_R16G16B16A16_UINT:               return "uvec4";
 731                 case VK_FORMAT_R16G16B16A16_SINT:               return "ivec4";
 732                 case VK_FORMAT_R16G16B16A16_SFLOAT:             return "vec4";
 733                 case VK_FORMAT_R32G32_UINT:                             return "uvec2";
 734                 case VK_FORMAT_R32G32_SINT:                             return "ivec2";
 735                 case VK_FORMAT_R32G32_SFLOAT:                   return "vec2";
 736                 // TODO: case VK_FORMAT_R64_UINT:               return "uint64";
 737                 // TODO: case VK_FORMAT_R64_SINT:               return "int64";
 738                 // TODO: case VK_FORMAT_R64_SFLOAT:             return "double";
 739
 740                 // 128-bit
 741                 case VK_FORMAT_R32G32B32A32_UINT:               return "uvec4";
 742                 case VK_FORMAT_R32G32B32A32_SINT:               return "ivec4";
 743                 case VK_FORMAT_R32G32B32A32_SFLOAT:             return "vec4";
 744                 // TODO: case VK_FORMAT_R64G64_UINT:    return "ulvec2";
 745                 // TODO: case VK_FORMAT_R64G64_SINT:    return "ilvec2";
 746                 // TODO: case VK_FORMAT_R64G64_SFLOAT:  return "dvec2";
 747
 748                 default:        TCU_THROW(InternalError, "Unknown format");
 749         }
 750 }
 751
 752 const char* getGlslAttachmentType (const vk::VkFormat format)
 753 {
 754         const tcu::TextureFormat                textureFormat   = mapVkFormat(format);
 755         const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(textureFormat.type);
 756
 757         switch (channelClass)
 758         {
 759                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 760                         return "ivec4";
 761
 762                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 763                         return "uvec4";
 764
 765                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 766                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 767                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 768                         return "vec4";
 769
 770                 default:
 771                         DE_FATAL("Unknown channel class");
 772                         return "";
 773         }
 774 }
 775
 776 const char* getGlslInputAttachmentType (const vk::VkFormat format)
 777 {
 778         const tcu::TextureFormat                textureFormat   = mapVkFormat(format);
 779         const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(textureFormat.type);
 780
 781         switch (channelClass)
 782         {
 783                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 784                         return "isubpassInput";
 785
 786                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 787                         return "usubpassInput";
 788
 789                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 790                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 791                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 792                         return "subpassInput";
 793
 794                 default:
 795                         DE_FATAL("Unknown channel class");
 796                         return "";
 797         }
 798 }
 799
 800 bool isPackedType (const vk::VkFormat format)
 801 {
 802         const tcu::TextureFormat        textureFormat   = mapVkFormat(format);
 803
 804         DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST == 48);
 805
 806         switch (textureFormat.type)
 807         {
 808                 case tcu::TextureFormat::UNORM_BYTE_44:
 809                 case tcu::TextureFormat::UNORM_SHORT_565:
 810                 case tcu::TextureFormat::UNORM_SHORT_555:
 811                 case tcu::TextureFormat::UNORM_SHORT_4444:
 812                 case tcu::TextureFormat::UNORM_SHORT_5551:
 813                 case tcu::TextureFormat::UNORM_SHORT_1555:
 814                 case tcu::TextureFormat::UNORM_INT_101010:
 815                 case tcu::TextureFormat::SNORM_INT_1010102_REV:
 816                 case tcu::TextureFormat::UNORM_INT_1010102_REV:
 817                 case tcu::TextureFormat::UNSIGNED_BYTE_44:
 818                 case tcu::TextureFormat::UNSIGNED_SHORT_565:
 819                 case tcu::TextureFormat::UNSIGNED_SHORT_4444:
 820                 case tcu::TextureFormat::UNSIGNED_SHORT_5551:
 821                 case tcu::TextureFormat::SIGNED_INT_1010102_REV:
 822                 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
 823                 case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
 824                 case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
 825                 case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
 826                 case tcu::TextureFormat::UNSIGNED_INT_24_8:
 827                 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
 828                 case tcu::TextureFormat::SSCALED_INT_1010102_REV:
 829                 case tcu::TextureFormat::USCALED_INT_1010102_REV:
 830                         return true;
 831
 832                 default:
 833                         return false;
 834         }
 835 }
 836
 837 bool isComponentSwizzled (const vk::VkFormat format)
 838 {
 839         const tcu::TextureFormat        textureFormat   = mapVkFormat(format);
 840
 841         DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
 842
 843         switch (textureFormat.order)
 844         {
 845                 case tcu::TextureFormat::ARGB:
 846                 case tcu::TextureFormat::ABGR:
 847                 case tcu::TextureFormat::BGR:
 848                 case tcu::TextureFormat::BGRA:
 849                 case tcu::TextureFormat::sBGR:
 850                 case tcu::TextureFormat::sBGRA:
 851                         return true;
 852
 853                 default:
 854                         return false;
 855         }
 856 }
 857
 858 int getNumUsedChannels (const vk::VkFormat format)
 859 {
 860         // make sure this function will be checked if type table is updated
 861         DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
 862
 863         const tcu::TextureFormat        textureFormat   = mapVkFormat(format);
 864
 865         return getNumUsedChannels(textureFormat.order);
 866 }
 867
 868 bool isFormatImageLoadStoreCapable (const vk::VkFormat format)
 869 {
 870         // These come from https://www.khronos.org/registry/vulkan/specs/1.1/html/vkspec.html#spirvenv-image-formats
 871         switch (format)
 872         {
 873                 case VK_FORMAT_R32G32B32A32_SFLOAT:
 874                 case VK_FORMAT_R16G16B16A16_SFLOAT:
 875                 case VK_FORMAT_R32_SFLOAT:
 876                 case VK_FORMAT_R8G8B8A8_UNORM:
 877                 case VK_FORMAT_R8G8B8A8_SNORM:
 878                 case VK_FORMAT_R32G32_SFLOAT:
 879                 case VK_FORMAT_R16G16_SFLOAT:
 880                 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
 881                 case VK_FORMAT_R16_SFLOAT:
 882                 case VK_FORMAT_R16G16B16A16_UNORM:
 883                 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
 884                 case VK_FORMAT_R16G16_UNORM:
 885                 case VK_FORMAT_R8G8_UNORM:
 886                 case VK_FORMAT_R16_UNORM:
 887                 case VK_FORMAT_R8_UNORM:
 888                 case VK_FORMAT_R16G16B16A16_SNORM:
 889                 case VK_FORMAT_R16G16_SNORM:
 890                 case VK_FORMAT_R8G8_SNORM:
 891                 case VK_FORMAT_R16_SNORM:
 892                 case VK_FORMAT_R8_SNORM:
 893                 case VK_FORMAT_R32G32B32A32_SINT:
 894                 case VK_FORMAT_R16G16B16A16_SINT:
 895                 case VK_FORMAT_R8G8B8A8_SINT:
 896                 case VK_FORMAT_R32_SINT:
 897                 case VK_FORMAT_R32G32_SINT:
 898                 case VK_FORMAT_R16G16_SINT:
 899                 case VK_FORMAT_R8G8_SINT:
 900                 case VK_FORMAT_R16_SINT:
 901                 case VK_FORMAT_R8_SINT:
 902                 case VK_FORMAT_R32G32B32A32_UINT:
 903                 case VK_FORMAT_R16G16B16A16_UINT:
 904                 case VK_FORMAT_R8G8B8A8_UINT:
 905                 case VK_FORMAT_R32_UINT:
 906                 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
 907                 case VK_FORMAT_R32G32_UINT:
 908                 case VK_FORMAT_R16G16_UINT:
 909                 case VK_FORMAT_R8G8_UINT:
 910                 case VK_FORMAT_R16_UINT:
 911                 case VK_FORMAT_R8_UINT:
 912                         return true;
 913
 914                 default:
 915                         return false;
 916         }
 917 }
 918
 919 std::string getFormatShortString (const VkFormat format)
 920 {
 921         const std::string fullName = getFormatName(format);
 922
 923         DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
 924
 925         return de::toLower(fullName.substr(10));
 926 }
 927
 928 std::vector<tcu::Vec4> createFullscreenQuad (void)
 929 {
 930         const tcu::Vec4 lowerLeftVertex         (-1.0f, -1.0f,  0.0f,   1.0f);
 931         const tcu::Vec4 upperLeftVertex         (-1.0f, 1.0f,   0.0f,   1.0f);
 932         const tcu::Vec4 lowerRightVertex        (1.0f,  -1.0f,  0.0f,   1.0f);
 933         const tcu::Vec4 upperRightVertex        (1.0f,  1.0f,   0.0f,   1.0f);
 934
 935         const tcu::Vec4 vertices[6] =
 936         {
 937                 lowerLeftVertex,
 938                 lowerRightVertex,
 939                 upperLeftVertex,
 940
 941                 upperLeftVertex,
 942                 lowerRightVertex,
 943                 upperRightVertex
 944         };
 945
 946         return std::vector<tcu::Vec4>(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices));
 947 }
 948
 949 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer)
 950 {
 951         const VkBufferImageCopy copyParams      =
 952         {
 953                 (VkDeviceSize)0u,                                               // bufferOffset
 954                 imageWidth,                                                             // bufferRowLength
 955                 imageHeight,                                                    // bufferImageHeight
 956                 {
 957                         VK_IMAGE_ASPECT_COLOR_BIT,                              // aspectMask
 958                         mipLevel,                                                               // mipLevel
 959                         layer,                                                                  // baseArrayLayer
 960                         1u,                                                                             // layerCount
 961                 },                                                                              // imageSubresource
 962                 { 0u, 0u, 0u },                                                 // imageOffset
 963                 {
 964                         imageWidth,
 965                         imageHeight,
 966                         1u
 967                 }                                                                               // imageExtent
 968         };
 969
 970         return copyParams;
 971 }
 972
 973 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer, const deUint32 bufferRowLength, const deUint32 bufferImageHeight)
 974 {
 975         const VkBufferImageCopy copyParams      =
 976         {
 977                 (VkDeviceSize)0u,                                               // bufferOffset
 978                 bufferRowLength,                                                // bufferRowLength
 979                 bufferImageHeight,                                              // bufferImageHeight
 980                 {
 981                         VK_IMAGE_ASPECT_COLOR_BIT,                              // aspectMask
 982                         mipLevel,                                                               // mipLevel
 983                         layer,                                                                  // baseArrayLayer
 984                         1u,                                                                             // layerCount
 985                 },                                                                              // imageSubresource
 986                 { 0u, 0u, 0u },                                                 // imageOffset
 987                 {
 988                         imageWidth,
 989                         imageHeight,
 990                         1u
 991                 }                                                                               // imageExtent
 992         };
 993
 994         return copyParams;
 995 }
 996
 997 void beginRenderPass (const DeviceInterface&    vk,
 998                                           const VkCommandBuffer         commandBuffer,
 999                                           const VkRenderPass            renderPass,
1000                                           const VkFramebuffer           framebuffer,
1001                                           const VkExtent2D&                     renderSize)
1002 {
1003         const VkRect2D renderArea =
1004         {
1005                 {0, 0},                 // VkOffset2D                           offset;
1006                 renderSize,             // VkExtent2D                           extent;
1007         };
1008
1009         beginRenderPass(vk, commandBuffer, renderPass, framebuffer, renderArea, tcu::Vec4(0.0f), 0.0f, 0u);
1010 }
1011
1012 } // image
1013 } // vkt