1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2016 The Khronos Group Inc.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief Image Tests Utility Classes
22 *//*--------------------------------------------------------------------*/
24 #include "vktImageTestsUtil.hpp"
25 #include "vkQueryUtil.hpp"
26 #include "vkTypeUtil.hpp"
27 #include "vkCmdUtil.hpp"
28 #include "vkObjUtil.hpp"
29 #include "tcuTextureUtil.hpp"
38 Buffer::Buffer (const DeviceInterface& vk,
39 const VkDevice device,
41 const VkBufferCreateInfo& bufferCreateInfo,
42 const MemoryRequirement memoryRequirement)
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()));
49 Image::Image (const DeviceInterface& vk,
50 const VkDevice device,
52 const VkImageCreateInfo& imageCreateInfo,
53 const MemoryRequirement memoryRequirement)
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()));
66 SparseImage::SparseImage (const vk::DeviceInterface& vkd,
68 vk::VkPhysicalDevice physicalDevice,
69 const vk::InstanceInterface& vki,
70 const vk::VkImageCreateInfo& createInfo,
71 const vk::VkQueue sparseQueue,
72 vk::Allocator& allocator,
73 const tcu::TextureFormat& format)
77 m_image = createImage(vkd, device, &createInfo);
78 m_semaphore = createSemaphore(vkd, device);
79 allocateAndBindSparseImage(vkd, device, physicalDevice, vki, createInfo, m_semaphore.get(), sparseQueue, allocator, m_allocations, format, m_image.get());
82 tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize)
87 case IMAGE_TYPE_BUFFER:
88 return tcu::UVec3(imageSize.x(), 1u, 1u);
90 case IMAGE_TYPE_1D_ARRAY:
91 return tcu::UVec3(imageSize.x(), imageSize.z(), 1u);
94 return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
96 case IMAGE_TYPE_2D_ARRAY:
98 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
100 case IMAGE_TYPE_CUBE:
101 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u);
103 case IMAGE_TYPE_CUBE_ARRAY:
104 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u * imageSize.z());
107 DE_FATAL("Unknown image type");
108 return tcu::UVec3(1u, 1u, 1u);
112 tcu::UVec3 getLayerSize (const ImageType imageType, const tcu::UVec3& imageSize)
117 case IMAGE_TYPE_1D_ARRAY:
118 case IMAGE_TYPE_BUFFER:
119 return tcu::UVec3(imageSize.x(), 1u, 1u);
122 case IMAGE_TYPE_2D_ARRAY:
123 case IMAGE_TYPE_CUBE:
124 case IMAGE_TYPE_CUBE_ARRAY:
125 return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
128 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
131 DE_FATAL("Unknown image type");
132 return tcu::UVec3(1u, 1u, 1u);
136 deUint32 getNumLayers (const ImageType imageType, const tcu::UVec3& imageSize)
143 case IMAGE_TYPE_BUFFER:
146 case IMAGE_TYPE_1D_ARRAY:
147 case IMAGE_TYPE_2D_ARRAY:
148 return imageSize.z();
150 case IMAGE_TYPE_CUBE:
153 case IMAGE_TYPE_CUBE_ARRAY:
154 return imageSize.z() * 6u;
157 DE_FATAL("Unknown image type");
162 deUint32 getNumPixels (const ImageType imageType, const tcu::UVec3& imageSize)
164 const tcu::UVec3 gridSize = getShaderGridSize(imageType, imageSize);
166 return gridSize.x() * gridSize.y() * gridSize.z();
169 deUint32 getDimensions (const ImageType imageType)
174 case IMAGE_TYPE_BUFFER:
177 case IMAGE_TYPE_1D_ARRAY:
181 case IMAGE_TYPE_2D_ARRAY:
182 case IMAGE_TYPE_CUBE:
183 case IMAGE_TYPE_CUBE_ARRAY:
188 DE_FATAL("Unknown image type");
193 deUint32 getLayerDimensions (const ImageType imageType)
198 case IMAGE_TYPE_BUFFER:
199 case IMAGE_TYPE_1D_ARRAY:
203 case IMAGE_TYPE_2D_ARRAY:
204 case IMAGE_TYPE_CUBE:
205 case IMAGE_TYPE_CUBE_ARRAY:
212 DE_FATAL("Unknown image type");
217 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
218 const deUint32 arraySize)
220 const VkBufferImageCopy copyParams =
222 0ull, // VkDeviceSize bufferOffset;
223 0u, // deUint32 bufferRowLength;
224 0u, // deUint32 bufferImageHeight;
225 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize), // VkImageSubresourceLayers imageSubresource;
226 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
227 extent, // VkExtent3D imageExtent;
232 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface& vk,
233 const VkDevice device,
234 const VkPipelineLayout pipelineLayout,
235 const VkRenderPass renderPass,
236 const VkShaderModule vertexModule,
237 const VkShaderModule fragmentModule,
238 const VkExtent2D renderSize,
239 const deUint32 colorAttachmentCount,
240 const bool dynamicSize)
242 std::vector<VkViewport> viewports;
243 std::vector<VkRect2D> scissors;
245 const VkViewport viewport = makeViewport(renderSize);
246 const VkRect2D scissor = makeRect2D(renderSize);
248 const VkFormat vertexFormatPosition = VK_FORMAT_R32G32B32A32_SFLOAT;
249 const deUint32 vertexSizePosition = tcu::getPixelSize(mapVkFormat(vertexFormatPosition));
250 const deUint32 vertexBufferOffsetPosition = 0u;
251 const deUint32 vertexDataStride = vertexSizePosition;
255 viewports.push_back(viewport);
256 scissors.push_back(scissor);
259 const VkVertexInputBindingDescription vertexInputBindingDescription =
261 0u, // deUint32 binding;
262 vertexDataStride, // deUint32 stride;
263 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
266 const VkVertexInputAttributeDescription vertexInputAttributeDescription =
268 0u, // deUint32 location;
269 0u, // deUint32 binding;
270 vertexFormatPosition, // VkFormat format;
271 vertexBufferOffsetPosition, // deUint32 offset;
274 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
276 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
277 DE_NULL, // const void* pNext;
278 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
279 1u, // deUint32 vertexBindingDescriptionCount;
280 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
281 1u, // deUint32 vertexAttributeDescriptionCount;
282 &vertexInputAttributeDescription // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
285 const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
286 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
288 VK_FALSE, // VkBool32 blendEnable;
289 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
290 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
291 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
292 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
293 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
294 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
295 colorComponentsAll // VkColorComponentFlags colorWriteMask;
298 std::vector<VkPipelineColorBlendAttachmentState> colorAttachments (colorAttachmentCount, colorBlendAttachmentState);
300 const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
302 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
303 DE_NULL, // const void* pNext;
304 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
305 VK_FALSE, // VkBool32 logicOpEnable;
306 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
307 (deUint32)colorAttachments.size(), // deUint32 attachmentCount;
308 colorAttachments.size() != 0 ? &colorAttachments[0] : DE_NULL, // const VkPipelineColorBlendAttachmentState* pAttachments;
309 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4];
312 return vk::makeGraphicsPipeline(vk, // const DeviceInterface& vk
313 device, // const VkDevice device
314 pipelineLayout, // const VkPipelineLayout pipelineLayout
315 vertexModule, // const VkShaderModule vertexShaderModule
316 DE_NULL, // const VkShaderModule tessellationControlModule
317 DE_NULL, // const VkShaderModule tessellationEvalModule
318 DE_NULL, // const VkShaderModule geometryShaderModule
319 fragmentModule, // const VkShaderModule fragmentShaderModule
320 renderPass, // const VkRenderPass renderPass
321 viewports, // const std::vector<VkViewport>& viewports
322 scissors, // const std::vector<VkRect2D>& scissors
323 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // const VkPrimitiveTopology topology
324 0u, // const deUint32 subpass
325 0u, // const deUint32 patchControlPoints
326 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo
327 DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
328 DE_NULL, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo
329 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo
330 &pipelineColorBlendStateInfo); // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo
333 //! A single-subpass render pass.
334 Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk,
335 const VkDevice device,
336 const VkFormat inputFormat,
337 const VkFormat colorFormat)
339 const VkAttachmentReference inputAttachmentRef =
341 0u, // deUint32 attachment;
342 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout;
345 const VkAttachmentReference colorAttachmentRef =
347 1u, // deUint32 attachment;
348 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
351 const VkSubpassDescription subpassDescription =
353 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
354 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
355 1u, // deUint32 inputAttachmentCount;
356 &inputAttachmentRef, // const VkAttachmentReference* pInputAttachments;
357 1u, // deUint32 colorAttachmentCount;
358 &colorAttachmentRef, // const VkAttachmentReference* pColorAttachments;
359 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
360 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
361 0u, // deUint32 preserveAttachmentCount;
362 DE_NULL // const deUint32* pPreserveAttachments;
365 const VkAttachmentDescription attachmentsDescriptions[] =
367 //inputAttachmentDescription,
369 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
370 inputFormat, // VkFormat format;
371 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
372 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
373 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
374 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
375 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
376 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
377 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
379 //colorAttachmentDescription
381 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
382 colorFormat, // VkFormat format;
383 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
384 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
385 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
386 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
387 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
388 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
389 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
393 const VkRenderPassCreateInfo renderPassInfo =
395 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
396 DE_NULL, // const void* pNext;
397 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
398 DE_LENGTH_OF_ARRAY(attachmentsDescriptions), // deUint32 attachmentCount;
399 attachmentsDescriptions, // const VkAttachmentDescription* pAttachments;
400 1u, // deUint32 subpassCount;
401 &subpassDescription, // const VkSubpassDescription* pSubpasses;
402 0u, // deUint32 dependencyCount;
403 DE_NULL // const VkSubpassDependency* pDependencies;
406 return createRenderPass(vk, device, &renderPassInfo);
409 VkImageViewUsageCreateInfo makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags)
411 VkImageViewUsageCreateInfo imageViewUsageCreateInfo =
413 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
414 DE_NULL, //const void* pNext;
415 imageUsageFlags, //VkImageUsageFlags usage;
418 return imageViewUsageCreateInfo;
421 VkSamplerCreateInfo makeSamplerCreateInfo ()
423 const VkSamplerCreateInfo defaultSamplerParams =
425 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
426 DE_NULL, // const void* pNext;
427 0u, // VkSamplerCreateFlags flags;
428 VK_FILTER_NEAREST, // VkFilter magFilter;
429 VK_FILTER_NEAREST, // VkFilter minFilter;
430 VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode;
431 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU;
432 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV;
433 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW;
434 0.0f, // float mipLodBias;
435 VK_FALSE, // VkBool32 anisotropyEnable;
436 1.0f, // float maxAnisotropy;
437 VK_FALSE, // VkBool32 compareEnable;
438 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp;
439 0.0f, // float minLod;
440 0.25f, // float maxLod;
441 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor;
442 VK_FALSE // VkBool32 unnormalizedCoordinates;
445 return defaultSamplerParams;
448 tcu::UVec3 getCompressedImageResolutionInBlocks (const vk::VkFormat format, const tcu::UVec3& size)
450 deUint32 blockWidth = getBlockWidth(format);
451 deUint32 blockHeight = getBlockHeight(format);
453 DE_ASSERT(size[2] == 1);
454 DE_ASSERT(blockWidth != 0 && blockHeight != 0);
456 deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth;
457 deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight;
459 return tcu::UVec3(widthInBlocks, heightInBlocks, 1);
462 tcu::UVec3 getCompressedImageResolutionBlockCeil (const vk::VkFormat format, const tcu::UVec3& size)
464 deUint32 blockWidth = getBlockWidth(format);
465 deUint32 blockHeight = getBlockHeight(format);
467 DE_ASSERT(size[2] == 1);
468 DE_ASSERT(blockWidth != 0 && blockHeight != 0);
470 deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth;
471 deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight;
473 return tcu::UVec3(blockWidth * widthInBlocks, blockHeight * heightInBlocks, 1);
476 VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
478 tcu::UVec3 sizeInBlocks = getCompressedImageResolutionInBlocks(format, size);
479 deUint32 blockBytes = getBlockSizeInBytes(format);
480 VkDeviceSize sizeBytes = sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes;
485 VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
487 const tcu::IVec3 sizeAsIVec3 = tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z());
488 const VkDeviceSize sizeBytes = getImageSizeBytes(sizeAsIVec3, format);
493 VkImageType mapImageType (const ImageType imageType)
498 case IMAGE_TYPE_1D_ARRAY:
499 case IMAGE_TYPE_BUFFER:
500 return VK_IMAGE_TYPE_1D;
503 case IMAGE_TYPE_2D_ARRAY:
504 case IMAGE_TYPE_CUBE:
505 case IMAGE_TYPE_CUBE_ARRAY:
506 return VK_IMAGE_TYPE_2D;
509 return VK_IMAGE_TYPE_3D;
513 return VK_IMAGE_TYPE_LAST;
517 VkImageViewType mapImageViewType (const ImageType imageType)
521 case IMAGE_TYPE_1D: return VK_IMAGE_VIEW_TYPE_1D;
522 case IMAGE_TYPE_1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
523 case IMAGE_TYPE_2D: return VK_IMAGE_VIEW_TYPE_2D;
524 case IMAGE_TYPE_2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
525 case IMAGE_TYPE_3D: return VK_IMAGE_VIEW_TYPE_3D;
526 case IMAGE_TYPE_CUBE: return VK_IMAGE_VIEW_TYPE_CUBE;
527 case IMAGE_TYPE_CUBE_ARRAY: return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
531 return VK_IMAGE_VIEW_TYPE_LAST;
535 std::string getImageTypeName (const ImageType imageType)
539 case IMAGE_TYPE_1D: return "1d";
540 case IMAGE_TYPE_1D_ARRAY: return "1d_array";
541 case IMAGE_TYPE_2D: return "2d";
542 case IMAGE_TYPE_2D_ARRAY: return "2d_array";
543 case IMAGE_TYPE_3D: return "3d";
544 case IMAGE_TYPE_CUBE: return "cube";
545 case IMAGE_TYPE_CUBE_ARRAY: return "cube_array";
546 case IMAGE_TYPE_BUFFER: return "buffer";
554 std::string getFormatPrefix (const tcu::TextureFormat& format)
556 const std::string image64 = ((mapTextureFormat(format) == VK_FORMAT_R64_UINT || mapTextureFormat(format) == VK_FORMAT_R64_SINT) ? "64" : "");
557 return tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" + image64 :
558 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" + image64 : "";
561 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample)
563 std::string formatPart = getFormatPrefix(format);
565 std::string imageTypePart;
570 case IMAGE_TYPE_2D: imageTypePart = "2DMS"; break;
571 case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DMSArray"; break;
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;
595 return formatPart + "image" + imageTypePart;
598 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
600 if (!isPackedType(mapTextureFormat(format)))
602 const char* orderPart;
603 const char* typePart;
605 switch (format.order)
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;
614 DE_FATAL("Order not found");
620 case tcu::TextureFormat::FLOAT: typePart = "32f"; break;
621 case tcu::TextureFormat::HALF_FLOAT: typePart = "16f"; break;
623 case tcu::TextureFormat::UNSIGNED_INT64: typePart = "64ui"; break;
624 case tcu::TextureFormat::UNSIGNED_INT32: typePart = "32ui"; break;
625 case tcu::TextureFormat::USCALED_INT16:
626 case tcu::TextureFormat::UNSIGNED_INT16: typePart = "16ui"; break;
627 case tcu::TextureFormat::USCALED_INT8:
628 case tcu::TextureFormat::UNSIGNED_INT8: typePart = "8ui"; break;
630 case tcu::TextureFormat::SIGNED_INT64: typePart = "64i"; break;
631 case tcu::TextureFormat::SIGNED_INT32: typePart = "32i"; break;
632 case tcu::TextureFormat::SSCALED_INT16:
633 case tcu::TextureFormat::SIGNED_INT16: typePart = "16i"; break;
634 case tcu::TextureFormat::SSCALED_INT8:
635 case tcu::TextureFormat::SIGNED_INT8: typePart = "8i"; break;
637 case tcu::TextureFormat::UNORM_INT16: typePart = "16"; break;
638 case tcu::TextureFormat::UNORM_INT8: typePart = "8"; break;
640 case tcu::TextureFormat::SNORM_INT16: typePart = "16_snorm"; break;
641 case tcu::TextureFormat::SNORM_INT8: typePart = "8_snorm"; break;
644 DE_FATAL("Type not found");
648 return std::string() + orderPart + typePart;
652 switch (mapTextureFormat(format))
654 case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return "r11f_g11f_b10f";
655 case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return "rgb10_a2";
656 case VK_FORMAT_A2B10G10R10_UINT_PACK32: return "rgb10_a2ui";
659 DE_FATAL("Qualifier not found");
665 std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
667 const char* typePart = DE_NULL;
668 const char* formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
669 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : "";
673 case VK_IMAGE_VIEW_TYPE_1D: typePart = "sampler1D"; break;
674 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: typePart = "sampler1DArray"; break;
675 case VK_IMAGE_VIEW_TYPE_2D: typePart = "sampler2D"; break;
676 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: typePart = "sampler2DArray"; break;
677 case VK_IMAGE_VIEW_TYPE_3D: typePart = "sampler3D"; break;
678 case VK_IMAGE_VIEW_TYPE_CUBE: typePart = "samplerCube"; break;
679 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: typePart = "samplerCubeArray"; break;
682 DE_FATAL("Unknown image view type");
686 return std::string(formatPart) + typePart;
690 const char* getGlslInputFormatType (const vk::VkFormat format)
695 case VK_FORMAT_R16G16B16A16_UNORM: return "subpassInput";
696 case VK_FORMAT_R16G16B16A16_SNORM: return "subpassInput";
697 case VK_FORMAT_R16G16B16A16_USCALED: return "subpassInput";
698 case VK_FORMAT_R16G16B16A16_SSCALED: return "subpassInput";
699 case VK_FORMAT_R16G16B16A16_UINT: return "usubpassInput";
700 case VK_FORMAT_R16G16B16A16_SINT: return "isubpassInput";
701 case VK_FORMAT_R16G16B16A16_SFLOAT: return "subpassInput";
702 case VK_FORMAT_R32G32_UINT: return "usubpassInput";
703 case VK_FORMAT_R32G32_SINT: return "isubpassInput";
704 case VK_FORMAT_R32G32_SFLOAT: return "subpassInput";
705 // TODO: case VK_FORMAT_R64_UINT: return "usubpassInput";
706 // TODO: case VK_FORMAT_R64_SINT: return "isubpassInput";
707 // TODO: case VK_FORMAT_R64_SFLOAT: return "subpassInput";
710 case VK_FORMAT_R32G32B32A32_UINT: return "usubpassInput";
711 case VK_FORMAT_R32G32B32A32_SINT: return "isubpassInput";
712 case VK_FORMAT_R32G32B32A32_SFLOAT: return "subpassInput";
713 // TODO: case VK_FORMAT_R64G64_UINT: return "usubpassInput";
714 // TODO: case VK_FORMAT_R64G64_SINT: return "isubpassInput";
715 // TODO: case VK_FORMAT_R64G64_SFLOAT: return "subpassInput";
717 default: TCU_THROW(InternalError, "Unknown format");
721 const char* getGlslFormatType (const vk::VkFormat format)
726 case VK_FORMAT_R16G16B16A16_UNORM: return "vec4";
727 case VK_FORMAT_R16G16B16A16_SNORM: return "vec4";
728 case VK_FORMAT_R16G16B16A16_USCALED: return "vec4";
729 case VK_FORMAT_R16G16B16A16_SSCALED: return "vec4";
730 case VK_FORMAT_R16G16B16A16_UINT: return "uvec4";
731 case VK_FORMAT_R16G16B16A16_SINT: return "ivec4";
732 case VK_FORMAT_R16G16B16A16_SFLOAT: return "vec4";
733 case VK_FORMAT_R32G32_UINT: return "uvec2";
734 case VK_FORMAT_R32G32_SINT: return "ivec2";
735 case VK_FORMAT_R32G32_SFLOAT: return "vec2";
736 // TODO: case VK_FORMAT_R64_UINT: return "uint64";
737 // TODO: case VK_FORMAT_R64_SINT: return "int64";
738 // TODO: case VK_FORMAT_R64_SFLOAT: return "double";
741 case VK_FORMAT_R32G32B32A32_UINT: return "uvec4";
742 case VK_FORMAT_R32G32B32A32_SINT: return "ivec4";
743 case VK_FORMAT_R32G32B32A32_SFLOAT: return "vec4";
744 // TODO: case VK_FORMAT_R64G64_UINT: return "ulvec2";
745 // TODO: case VK_FORMAT_R64G64_SINT: return "ilvec2";
746 // TODO: case VK_FORMAT_R64G64_SFLOAT: return "dvec2";
748 default: TCU_THROW(InternalError, "Unknown format");
752 const char* getGlslAttachmentType (const vk::VkFormat format)
754 const tcu::TextureFormat textureFormat = mapVkFormat(format);
755 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type);
757 switch (channelClass)
759 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
762 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
765 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
766 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
767 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
771 DE_FATAL("Unknown channel class");
776 const char* getGlslInputAttachmentType (const vk::VkFormat format)
778 const tcu::TextureFormat textureFormat = mapVkFormat(format);
779 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type);
781 switch (channelClass)
783 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
784 return "isubpassInput";
786 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
787 return "usubpassInput";
789 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
790 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
791 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
792 return "subpassInput";
795 DE_FATAL("Unknown channel class");
800 bool isPackedType (const vk::VkFormat format)
802 const tcu::TextureFormat textureFormat = mapVkFormat(format);
804 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST == 48);
806 switch (textureFormat.type)
808 case tcu::TextureFormat::UNORM_BYTE_44:
809 case tcu::TextureFormat::UNORM_SHORT_565:
810 case tcu::TextureFormat::UNORM_SHORT_555:
811 case tcu::TextureFormat::UNORM_SHORT_4444:
812 case tcu::TextureFormat::UNORM_SHORT_5551:
813 case tcu::TextureFormat::UNORM_SHORT_1555:
814 case tcu::TextureFormat::UNORM_INT_101010:
815 case tcu::TextureFormat::SNORM_INT_1010102_REV:
816 case tcu::TextureFormat::UNORM_INT_1010102_REV:
817 case tcu::TextureFormat::UNSIGNED_BYTE_44:
818 case tcu::TextureFormat::UNSIGNED_SHORT_565:
819 case tcu::TextureFormat::UNSIGNED_SHORT_4444:
820 case tcu::TextureFormat::UNSIGNED_SHORT_5551:
821 case tcu::TextureFormat::SIGNED_INT_1010102_REV:
822 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
823 case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
824 case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
825 case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
826 case tcu::TextureFormat::UNSIGNED_INT_24_8:
827 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
828 case tcu::TextureFormat::SSCALED_INT_1010102_REV:
829 case tcu::TextureFormat::USCALED_INT_1010102_REV:
837 bool isComponentSwizzled (const vk::VkFormat format)
839 const tcu::TextureFormat textureFormat = mapVkFormat(format);
841 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
843 switch (textureFormat.order)
845 case tcu::TextureFormat::ARGB:
846 case tcu::TextureFormat::ABGR:
847 case tcu::TextureFormat::BGR:
848 case tcu::TextureFormat::BGRA:
849 case tcu::TextureFormat::sBGR:
850 case tcu::TextureFormat::sBGRA:
858 int getNumUsedChannels (const vk::VkFormat format)
860 // make sure this function will be checked if type table is updated
861 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
863 const tcu::TextureFormat textureFormat = mapVkFormat(format);
865 return getNumUsedChannels(textureFormat.order);
868 bool isFormatImageLoadStoreCapable (const vk::VkFormat format)
870 // These come from https://www.khronos.org/registry/vulkan/specs/1.1/html/vkspec.html#spirvenv-image-formats
873 case VK_FORMAT_R32G32B32A32_SFLOAT:
874 case VK_FORMAT_R16G16B16A16_SFLOAT:
875 case VK_FORMAT_R32_SFLOAT:
876 case VK_FORMAT_R8G8B8A8_UNORM:
877 case VK_FORMAT_R8G8B8A8_SNORM:
878 case VK_FORMAT_R32G32_SFLOAT:
879 case VK_FORMAT_R16G16_SFLOAT:
880 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
881 case VK_FORMAT_R16_SFLOAT:
882 case VK_FORMAT_R16G16B16A16_UNORM:
883 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
884 case VK_FORMAT_R16G16_UNORM:
885 case VK_FORMAT_R8G8_UNORM:
886 case VK_FORMAT_R16_UNORM:
887 case VK_FORMAT_R8_UNORM:
888 case VK_FORMAT_R16G16B16A16_SNORM:
889 case VK_FORMAT_R16G16_SNORM:
890 case VK_FORMAT_R8G8_SNORM:
891 case VK_FORMAT_R16_SNORM:
892 case VK_FORMAT_R8_SNORM:
893 case VK_FORMAT_R32G32B32A32_SINT:
894 case VK_FORMAT_R16G16B16A16_SINT:
895 case VK_FORMAT_R8G8B8A8_SINT:
896 case VK_FORMAT_R32_SINT:
897 case VK_FORMAT_R32G32_SINT:
898 case VK_FORMAT_R16G16_SINT:
899 case VK_FORMAT_R8G8_SINT:
900 case VK_FORMAT_R16_SINT:
901 case VK_FORMAT_R8_SINT:
902 case VK_FORMAT_R32G32B32A32_UINT:
903 case VK_FORMAT_R16G16B16A16_UINT:
904 case VK_FORMAT_R8G8B8A8_UINT:
905 case VK_FORMAT_R32_UINT:
906 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
907 case VK_FORMAT_R32G32_UINT:
908 case VK_FORMAT_R16G16_UINT:
909 case VK_FORMAT_R8G8_UINT:
910 case VK_FORMAT_R16_UINT:
911 case VK_FORMAT_R8_UINT:
919 std::string getFormatShortString (const VkFormat format)
921 const std::string fullName = getFormatName(format);
923 DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
925 return de::toLower(fullName.substr(10));
928 std::vector<tcu::Vec4> createFullscreenQuad (void)
930 const tcu::Vec4 lowerLeftVertex (-1.0f, -1.0f, 0.0f, 1.0f);
931 const tcu::Vec4 upperLeftVertex (-1.0f, 1.0f, 0.0f, 1.0f);
932 const tcu::Vec4 lowerRightVertex (1.0f, -1.0f, 0.0f, 1.0f);
933 const tcu::Vec4 upperRightVertex (1.0f, 1.0f, 0.0f, 1.0f);
935 const tcu::Vec4 vertices[6] =
946 return std::vector<tcu::Vec4>(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices));
949 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer)
951 const VkBufferImageCopy copyParams =
953 (VkDeviceSize)0u, // bufferOffset
954 imageWidth, // bufferRowLength
955 imageHeight, // bufferImageHeight
957 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
958 mipLevel, // mipLevel
959 layer, // baseArrayLayer
961 }, // imageSubresource
962 { 0u, 0u, 0u }, // imageOffset
973 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer, const deUint32 bufferRowLength, const deUint32 bufferImageHeight)
975 const VkBufferImageCopy copyParams =
977 (VkDeviceSize)0u, // bufferOffset
978 bufferRowLength, // bufferRowLength
979 bufferImageHeight, // bufferImageHeight
981 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
982 mipLevel, // mipLevel
983 layer, // baseArrayLayer
985 }, // imageSubresource
986 { 0u, 0u, 0u }, // imageOffset
997 void beginRenderPass (const DeviceInterface& vk,
998 const VkCommandBuffer commandBuffer,
999 const VkRenderPass renderPass,
1000 const VkFramebuffer framebuffer,
1001 const VkExtent2D& renderSize)
1003 const VkRect2D renderArea =
1005 {0, 0}, // VkOffset2D offset;
1006 renderSize, // VkExtent2D extent;
1009 beginRenderPass(vk, commandBuffer, renderPass, framebuffer, renderArea, tcu::Vec4(0.0f), 0.0f, 0u);