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