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