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 #ifndef CTS_USES_VULKANSC
67 SparseImage::SparseImage (const vk::DeviceInterface& vkd,
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)
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());
82 #endif // CTS_USES_VULKANSC
84 tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize)
89 case IMAGE_TYPE_BUFFER:
90 return tcu::UVec3(imageSize.x(), 1u, 1u);
92 case IMAGE_TYPE_1D_ARRAY:
93 return tcu::UVec3(imageSize.x(), imageSize.z(), 1u);
96 return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
98 case IMAGE_TYPE_2D_ARRAY:
100 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
102 case IMAGE_TYPE_CUBE:
103 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u);
105 case IMAGE_TYPE_CUBE_ARRAY:
106 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u * imageSize.z());
109 DE_FATAL("Unknown image type");
110 return tcu::UVec3(1u, 1u, 1u);
114 tcu::UVec3 getLayerSize (const ImageType imageType, const tcu::UVec3& imageSize)
119 case IMAGE_TYPE_1D_ARRAY:
120 case IMAGE_TYPE_BUFFER:
121 return tcu::UVec3(imageSize.x(), 1u, 1u);
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);
130 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
133 DE_FATAL("Unknown image type");
134 return tcu::UVec3(1u, 1u, 1u);
138 deUint32 getNumLayers (const ImageType imageType, const tcu::UVec3& imageSize)
145 case IMAGE_TYPE_BUFFER:
148 case IMAGE_TYPE_1D_ARRAY:
149 case IMAGE_TYPE_2D_ARRAY:
150 return imageSize.z();
152 case IMAGE_TYPE_CUBE:
155 case IMAGE_TYPE_CUBE_ARRAY:
156 return imageSize.z() * 6u;
159 DE_FATAL("Unknown image type");
164 deUint32 getNumPixels (const ImageType imageType, const tcu::UVec3& imageSize)
166 const tcu::UVec3 gridSize = getShaderGridSize(imageType, imageSize);
168 return gridSize.x() * gridSize.y() * gridSize.z();
171 deUint32 getDimensions (const ImageType imageType)
176 case IMAGE_TYPE_BUFFER:
179 case IMAGE_TYPE_1D_ARRAY:
183 case IMAGE_TYPE_2D_ARRAY:
184 case IMAGE_TYPE_CUBE:
185 case IMAGE_TYPE_CUBE_ARRAY:
190 DE_FATAL("Unknown image type");
195 deUint32 getLayerDimensions (const ImageType imageType)
200 case IMAGE_TYPE_BUFFER:
201 case IMAGE_TYPE_1D_ARRAY:
205 case IMAGE_TYPE_2D_ARRAY:
206 case IMAGE_TYPE_CUBE:
207 case IMAGE_TYPE_CUBE_ARRAY:
214 DE_FATAL("Unknown image type");
219 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
220 const deUint32 arraySize)
222 const VkBufferImageCopy copyParams =
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;
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)
244 std::vector<VkViewport> viewports;
245 std::vector<VkRect2D> scissors;
247 const VkViewport viewport = makeViewport(renderSize);
248 const VkRect2D scissor = makeRect2D(renderSize);
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;
257 viewports.push_back(viewport);
258 scissors.push_back(scissor);
261 const VkVertexInputBindingDescription vertexInputBindingDescription =
263 0u, // deUint32 binding;
264 vertexDataStride, // deUint32 stride;
265 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
268 const VkVertexInputAttributeDescription vertexInputAttributeDescription =
270 0u, // deUint32 location;
271 0u, // deUint32 binding;
272 vertexFormatPosition, // VkFormat format;
273 vertexBufferOffsetPosition, // deUint32 offset;
276 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
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;
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 =
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;
300 std::vector<VkPipelineColorBlendAttachmentState> colorAttachments (colorAttachmentCount, colorBlendAttachmentState);
302 const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
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];
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
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)
341 const VkAttachmentReference inputAttachmentRef =
343 0u, // deUint32 attachment;
344 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout;
347 const VkAttachmentReference colorAttachmentRef =
349 1u, // deUint32 attachment;
350 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
353 const VkSubpassDescription subpassDescription =
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;
367 const VkAttachmentDescription attachmentsDescriptions[] =
369 //inputAttachmentDescription,
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;
381 //colorAttachmentDescription
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;
395 const VkRenderPassCreateInfo renderPassInfo =
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;
408 return createRenderPass(vk, device, &renderPassInfo);
411 VkImageViewUsageCreateInfo makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags)
413 VkImageViewUsageCreateInfo imageViewUsageCreateInfo =
415 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, //VkStructureType sType;
416 DE_NULL, //const void* pNext;
417 imageUsageFlags, //VkImageUsageFlags usage;
420 return imageViewUsageCreateInfo;
423 VkSamplerCreateInfo makeSamplerCreateInfo ()
425 const VkSamplerCreateInfo defaultSamplerParams =
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;
447 return defaultSamplerParams;
450 tcu::UVec3 getCompressedImageResolutionInBlocks (const vk::VkFormat format, const tcu::UVec3& size)
452 deUint32 blockWidth = getBlockWidth(format);
453 deUint32 blockHeight = getBlockHeight(format);
455 DE_ASSERT(size[2] == 1);
456 DE_ASSERT(blockWidth != 0 && blockHeight != 0);
458 deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth;
459 deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight;
461 return tcu::UVec3(widthInBlocks, heightInBlocks, 1);
464 tcu::UVec3 getCompressedImageResolutionBlockCeil (const vk::VkFormat format, const tcu::UVec3& size)
466 deUint32 blockWidth = getBlockWidth(format);
467 deUint32 blockHeight = getBlockHeight(format);
469 DE_ASSERT(size[2] == 1);
470 DE_ASSERT(blockWidth != 0 && blockHeight != 0);
472 deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth;
473 deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight;
475 return tcu::UVec3(blockWidth * widthInBlocks, blockHeight * heightInBlocks, 1);
478 VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
480 tcu::UVec3 sizeInBlocks = getCompressedImageResolutionInBlocks(format, size);
481 deUint32 blockBytes = getBlockSizeInBytes(format);
482 VkDeviceSize sizeBytes = sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes;
487 VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
489 const tcu::IVec3 sizeAsIVec3 = tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z());
490 const VkDeviceSize sizeBytes = getImageSizeBytes(sizeAsIVec3, format);
495 VkImageType mapImageType (const ImageType imageType)
500 case IMAGE_TYPE_1D_ARRAY:
501 case IMAGE_TYPE_BUFFER:
502 return VK_IMAGE_TYPE_1D;
505 case IMAGE_TYPE_2D_ARRAY:
506 case IMAGE_TYPE_CUBE:
507 case IMAGE_TYPE_CUBE_ARRAY:
508 return VK_IMAGE_TYPE_2D;
511 return VK_IMAGE_TYPE_3D;
515 return VK_IMAGE_TYPE_LAST;
519 VkImageViewType mapImageViewType (const ImageType imageType)
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;
533 return VK_IMAGE_VIEW_TYPE_LAST;
537 std::string getImageTypeName (const ImageType imageType)
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";
556 std::string getFormatPrefix (const tcu::TextureFormat& format)
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 : "";
563 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample)
565 std::string formatPart = getFormatPrefix(format);
567 std::string imageTypePart;
572 case IMAGE_TYPE_2D: imageTypePart = "2DMS"; break;
573 case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DMSArray"; break;
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;
597 return formatPart + "image" + imageTypePart;
600 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
602 if (!isPackedType(mapTextureFormat(format)))
604 const char* orderPart;
605 const char* typePart;
607 switch (format.order)
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;
616 DE_FATAL("Order not found");
622 case tcu::TextureFormat::FLOAT: typePart = "32f"; break;
623 case tcu::TextureFormat::HALF_FLOAT: typePart = "16f"; break;
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;
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;
639 case tcu::TextureFormat::UNORM_INT16: typePart = "16"; break;
640 case tcu::TextureFormat::UNORM_INT8: typePart = "8"; break;
642 case tcu::TextureFormat::SNORM_INT16: typePart = "16_snorm"; break;
643 case tcu::TextureFormat::SNORM_INT8: typePart = "8_snorm"; break;
646 DE_FATAL("Type not found");
650 return std::string() + orderPart + typePart;
654 switch (mapTextureFormat(format))
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";
661 DE_FATAL("Qualifier not found");
667 std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
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" : "";
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;
684 DE_FATAL("Unknown image view type");
688 return std::string(formatPart) + typePart;
692 const char* getGlslInputFormatType (const vk::VkFormat format)
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";
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";
719 default: TCU_THROW(InternalError, "Unknown format");
723 const char* getGlslFormatType (const vk::VkFormat format)
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";
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";
750 default: TCU_THROW(InternalError, "Unknown format");
754 const char* getGlslAttachmentType (const vk::VkFormat format)
756 const tcu::TextureFormat textureFormat = mapVkFormat(format);
757 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type);
759 switch (channelClass)
761 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
764 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
767 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
768 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
769 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
773 DE_FATAL("Unknown channel class");
778 const char* getGlslInputAttachmentType (const vk::VkFormat format)
780 const tcu::TextureFormat textureFormat = mapVkFormat(format);
781 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type);
783 switch (channelClass)
785 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
786 return "isubpassInput";
788 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
789 return "usubpassInput";
791 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
792 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
793 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
794 return "subpassInput";
797 DE_FATAL("Unknown channel class");
802 bool isPackedType (const vk::VkFormat format)
804 const tcu::TextureFormat textureFormat = mapVkFormat(format);
806 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST == 48);
808 switch (textureFormat.type)
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:
839 bool isComponentSwizzled (const vk::VkFormat format)
841 const tcu::TextureFormat textureFormat = mapVkFormat(format);
843 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
845 switch (textureFormat.order)
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:
860 int getNumUsedChannels (const vk::VkFormat format)
862 // make sure this function will be checked if type table is updated
863 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 22);
865 const tcu::TextureFormat textureFormat = mapVkFormat(format);
867 return getNumUsedChannels(textureFormat.order);
870 bool isFormatImageLoadStoreCapable (const vk::VkFormat format)
872 // These come from https://www.khronos.org/registry/vulkan/specs/1.1/html/vkspec.html#spirvenv-image-formats
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:
921 std::string getFormatShortString (const VkFormat format)
923 const std::string fullName = getFormatName(format);
925 DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
927 return de::toLower(fullName.substr(10));
930 std::vector<tcu::Vec4> createFullscreenQuad (void)
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);
937 const tcu::Vec4 vertices[6] =
948 return std::vector<tcu::Vec4>(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices));
951 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer)
953 const VkBufferImageCopy copyParams =
955 (VkDeviceSize)0u, // bufferOffset
956 imageWidth, // bufferRowLength
957 imageHeight, // bufferImageHeight
959 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
960 mipLevel, // mipLevel
961 layer, // baseArrayLayer
963 }, // imageSubresource
964 { 0u, 0u, 0u }, // imageOffset
975 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer, const deUint32 bufferRowLength, const deUint32 bufferImageHeight)
977 const VkBufferImageCopy copyParams =
979 (VkDeviceSize)0u, // bufferOffset
980 bufferRowLength, // bufferRowLength
981 bufferImageHeight, // bufferImageHeight
983 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
984 mipLevel, // mipLevel
985 layer, // baseArrayLayer
987 }, // imageSubresource
988 { 0u, 0u, 0u }, // imageOffset
999 void beginRenderPass (const DeviceInterface& vk,
1000 const VkCommandBuffer commandBuffer,
1001 const VkRenderPass renderPass,
1002 const VkFramebuffer framebuffer,
1003 const VkExtent2D& renderSize)
1005 const VkRect2D renderArea =
1007 {0, 0}, // VkOffset2D offset;
1008 renderSize, // VkExtent2D extent;
1011 beginRenderPass(vk, commandBuffer, renderPass, framebuffer, renderArea, tcu::Vec4(0.0f), 0.0f, 0u);