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 "tcuTextureUtil.hpp"
36 Buffer::Buffer (const DeviceInterface& vk,
37 const VkDevice device,
39 const VkBufferCreateInfo& bufferCreateInfo,
40 const MemoryRequirement memoryRequirement)
42 m_buffer = createBuffer(vk, device, &bufferCreateInfo);
43 m_allocation = allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), memoryRequirement);
44 VK_CHECK(vk.bindBufferMemory(device, *m_buffer, m_allocation->getMemory(), m_allocation->getOffset()));
47 Image::Image (const DeviceInterface& vk,
48 const VkDevice device,
50 const VkImageCreateInfo& imageCreateInfo,
51 const MemoryRequirement memoryRequirement)
53 m_image = createImage(vk, device, &imageCreateInfo);
54 m_allocation = allocator.allocate(getImageMemoryRequirements(vk, device, *m_image), memoryRequirement);
55 VK_CHECK(vk.bindImageMemory(device, *m_image, m_allocation->getMemory(), m_allocation->getOffset()));
58 struct CompressedFormatParameters
66 CompressedFormatParameters compressedFormatParameters[VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_BC1_RGB_UNORM_BLOCK + 1] =
68 { VK_FORMAT_BC1_RGB_UNORM_BLOCK, 8, 4, 4 },
69 { VK_FORMAT_BC1_RGB_SRGB_BLOCK, 8, 4, 4 },
70 { VK_FORMAT_BC1_RGBA_UNORM_BLOCK, 8, 4, 4 },
71 { VK_FORMAT_BC1_RGBA_SRGB_BLOCK, 8, 4, 4 },
72 { VK_FORMAT_BC2_UNORM_BLOCK, 16, 4, 4 },
73 { VK_FORMAT_BC2_SRGB_BLOCK, 16, 4, 4 },
74 { VK_FORMAT_BC3_UNORM_BLOCK, 16, 4, 4 },
75 { VK_FORMAT_BC3_SRGB_BLOCK, 16, 4, 4 },
76 { VK_FORMAT_BC4_UNORM_BLOCK, 8, 4, 4 },
77 { VK_FORMAT_BC4_SNORM_BLOCK, 8, 4, 4 },
78 { VK_FORMAT_BC5_UNORM_BLOCK, 16, 4, 4 },
79 { VK_FORMAT_BC5_SNORM_BLOCK, 16, 4, 4 },
80 { VK_FORMAT_BC6H_UFLOAT_BLOCK, 16, 4, 4 },
81 { VK_FORMAT_BC6H_SFLOAT_BLOCK, 16, 4, 4 },
82 { VK_FORMAT_BC7_UNORM_BLOCK, 16, 4, 4 },
83 { VK_FORMAT_BC7_SRGB_BLOCK, 16, 4, 4 },
84 { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, 8, 4, 4 },
85 { VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, 8, 4, 4 },
86 { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, 8, 4, 4 },
87 { VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, 8, 4, 4 },
88 { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, 16, 4, 4 },
89 { VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, 16, 4, 4 },
90 { VK_FORMAT_EAC_R11_UNORM_BLOCK, 8, 4, 4 },
91 { VK_FORMAT_EAC_R11_SNORM_BLOCK, 8, 4, 4 },
92 { VK_FORMAT_EAC_R11G11_UNORM_BLOCK, 16, 4, 4 },
93 { VK_FORMAT_EAC_R11G11_SNORM_BLOCK, 16, 4, 4 },
94 { VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 16, 4, 4 },
95 { VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 16, 4, 4 },
96 { VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 16, 5, 4 },
97 { VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 16, 5, 4 },
98 { VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 16, 5, 5 },
99 { VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 16, 5, 5 },
100 { VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 16, 6, 5 },
101 { VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 16, 6, 5 },
102 { VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 16, 6, 6 },
103 { VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 16, 6, 6 },
104 { VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 16, 8, 5 },
105 { VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 16, 8, 5 },
106 { VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 16, 8, 6 },
107 { VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 16, 8, 6 },
108 { VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 16, 8, 8 },
109 { VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 16, 8, 8 },
110 { VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 16, 10, 5 },
111 { VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 16, 10, 5 },
112 { VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 16, 10, 6 },
113 { VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 16, 10, 6 },
114 { VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 16, 10, 8 },
115 { VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 16, 10, 8 },
116 { VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 16, 10, 10 },
117 { VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 16, 10, 10 },
118 { VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 16, 12, 10 },
119 { VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 16, 12, 10 },
120 { VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 16, 12, 12 },
121 { VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 16, 12, 12 },
124 deUint32 getBlockSizeInBytes(const VkFormat compressedFormat)
126 deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
128 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
129 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
131 return compressedFormatParameters[formatNdx].blockBytes;
134 deUint32 getBlockWidth(const VkFormat compressedFormat)
136 deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
138 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
139 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
141 return compressedFormatParameters[formatNdx].blockWidth;
144 deUint32 getBlockHeight(const VkFormat compressedFormat)
146 deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
148 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
149 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
151 return compressedFormatParameters[formatNdx].blockHeight;
154 tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize)
159 case IMAGE_TYPE_BUFFER:
160 return tcu::UVec3(imageSize.x(), 1u, 1u);
162 case IMAGE_TYPE_1D_ARRAY:
163 return tcu::UVec3(imageSize.x(), imageSize.z(), 1u);
166 return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
168 case IMAGE_TYPE_2D_ARRAY:
170 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
172 case IMAGE_TYPE_CUBE:
173 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u);
175 case IMAGE_TYPE_CUBE_ARRAY:
176 return tcu::UVec3(imageSize.x(), imageSize.y(), 6u * imageSize.z());
179 DE_FATAL("Unknown image type");
180 return tcu::UVec3(1u, 1u, 1u);
184 tcu::UVec3 getLayerSize (const ImageType imageType, const tcu::UVec3& imageSize)
189 case IMAGE_TYPE_1D_ARRAY:
190 case IMAGE_TYPE_BUFFER:
191 return tcu::UVec3(imageSize.x(), 1u, 1u);
194 case IMAGE_TYPE_2D_ARRAY:
195 case IMAGE_TYPE_CUBE:
196 case IMAGE_TYPE_CUBE_ARRAY:
197 return tcu::UVec3(imageSize.x(), imageSize.y(), 1u);
200 return tcu::UVec3(imageSize.x(), imageSize.y(), imageSize.z());
203 DE_FATAL("Unknown image type");
204 return tcu::UVec3(1u, 1u, 1u);
208 deUint32 getNumLayers (const ImageType imageType, const tcu::UVec3& imageSize)
215 case IMAGE_TYPE_BUFFER:
218 case IMAGE_TYPE_1D_ARRAY:
219 case IMAGE_TYPE_2D_ARRAY:
220 return imageSize.z();
222 case IMAGE_TYPE_CUBE:
225 case IMAGE_TYPE_CUBE_ARRAY:
226 return imageSize.z() * 6u;
229 DE_FATAL("Unknown image type");
234 deUint32 getNumPixels (const ImageType imageType, const tcu::UVec3& imageSize)
236 const tcu::UVec3 gridSize = getShaderGridSize(imageType, imageSize);
238 return gridSize.x() * gridSize.y() * gridSize.z();
241 deUint32 getDimensions (const ImageType imageType)
246 case IMAGE_TYPE_BUFFER:
249 case IMAGE_TYPE_1D_ARRAY:
253 case IMAGE_TYPE_2D_ARRAY:
254 case IMAGE_TYPE_CUBE:
255 case IMAGE_TYPE_CUBE_ARRAY:
260 DE_FATAL("Unknown image type");
265 deUint32 getLayerDimensions (const ImageType imageType)
270 case IMAGE_TYPE_BUFFER:
271 case IMAGE_TYPE_1D_ARRAY:
275 case IMAGE_TYPE_2D_ARRAY:
276 case IMAGE_TYPE_CUBE:
277 case IMAGE_TYPE_CUBE_ARRAY:
284 DE_FATAL("Unknown image type");
289 std::vector<tcu::UVec3> getMipLevelSizes (tcu::UVec3 baseSize)
291 std::vector<tcu::UVec3> levels;
292 levels.push_back(baseSize);
294 while (baseSize.x() != 1 || baseSize.y() != 1 || baseSize.z() != 1)
296 baseSize.x() = deMax32(baseSize.x() >> 1, 1);
297 baseSize.y() = deMax32(baseSize.y() >> 1, 1);
298 baseSize.z() = deMax32(baseSize.z() >> 1, 1);
299 levels.push_back(baseSize);
305 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize bufferSize,
306 const VkBufferUsageFlags usage)
308 const VkBufferCreateInfo bufferCreateInfo =
310 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
311 DE_NULL, // const void* pNext;
312 0u, // VkBufferCreateFlags flags;
313 bufferSize, // VkDeviceSize size;
314 usage, // VkBufferUsageFlags usage;
315 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
316 0u, // deUint32 queueFamilyIndexCount;
317 DE_NULL, // const deUint32* pQueueFamilyIndices;
319 return bufferCreateInfo;
322 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
323 const deUint32 arraySize)
325 const VkBufferImageCopy copyParams =
327 0ull, // VkDeviceSize bufferOffset;
328 0u, // deUint32 bufferRowLength;
329 0u, // deUint32 bufferImageHeight;
330 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize), // VkImageSubresourceLayers imageSubresource;
331 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
332 extent, // VkExtent3D imageExtent;
337 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk,
338 const VkDevice device,
339 const VkDescriptorSetLayout descriptorSetLayout)
341 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
343 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
344 DE_NULL, // const void* pNext;
345 0u, // VkPipelineLayoutCreateFlags flags;
346 1u, // deUint32 setLayoutCount;
347 &descriptorSetLayout, // const VkDescriptorSetLayout* pSetLayouts;
348 0u, // deUint32 pushConstantRangeCount;
349 DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
351 return createPipelineLayout(vk, device, &pipelineLayoutParams);
354 Move<VkPipeline> makeComputePipeline (const DeviceInterface& vk,
355 const VkDevice device,
356 const VkPipelineLayout pipelineLayout,
357 const VkShaderModule shaderModule)
359 const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
361 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
362 DE_NULL, // const void* pNext;
363 0u, // VkPipelineShaderStageCreateFlags flags;
364 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
365 shaderModule, // VkShaderModule module;
366 "main", // const char* pName;
367 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
369 const VkComputePipelineCreateInfo pipelineCreateInfo =
371 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
372 DE_NULL, // const void* pNext;
373 0u, // VkPipelineCreateFlags flags;
374 pipelineShaderStageParams, // VkPipelineShaderStageCreateInfo stage;
375 pipelineLayout, // VkPipelineLayout layout;
376 DE_NULL, // VkPipeline basePipelineHandle;
377 0, // deInt32 basePipelineIndex;
379 return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo);
382 Move<VkPipeline> makeGraphicsPipeline (const DeviceInterface& vk,
383 const VkDevice device,
384 const VkPipelineLayout pipelineLayout,
385 const VkRenderPass renderPass,
386 const VkShaderModule vertexModule,
387 const VkShaderModule fragmentModule,
388 const VkExtent2D renderSize,
389 const deUint32 colorAttachmentCount)
391 const VkFormat vertexFormatPosition = VK_FORMAT_R32G32B32A32_SFLOAT;
392 const deUint32 vertexSizePosition = tcu::getPixelSize(mapVkFormat(vertexFormatPosition));
393 const deUint32 vertexBufferOffsetPosition = 0u;
394 const deUint32 vertexDataStride = vertexSizePosition;
396 const VkVertexInputBindingDescription vertexBinding =
398 0u, // deUint32 binding;
399 vertexDataStride, // deUint32 stride;
400 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
403 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
407 0u, // deUint32 location;
408 0u, // deUint32 binding;
409 vertexFormatPosition, // VkFormat format;
410 vertexBufferOffsetPosition, // deUint32 offset;
414 const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
416 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
417 DE_NULL, // const void* pNext;
418 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
419 1u, // uint32_t vertexBindingDescriptionCount;
420 &vertexBinding, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
421 DE_LENGTH_OF_ARRAY(vertexInputAttributeDescriptions), // uint32_t vertexAttributeDescriptionCount;
422 vertexInputAttributeDescriptions, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
425 const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
427 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
428 DE_NULL, // const void* pNext;
429 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
430 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
431 VK_FALSE, // VkBool32 primitiveRestartEnable;
434 const VkViewport viewport =
436 0.0f, // float originX;
437 0.0f, // float originY;
438 (float)renderSize.width, // float width;
439 (float)renderSize.height, // float height;
440 0.0f, // float minDepth;
441 1.0f // float maxDepth;
444 const VkRect2D scissor =
446 { 0u, 0u }, // VkOffset2D offset;
447 renderSize // VkExtent2D extent;
450 const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
452 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
453 DE_NULL, // const void* pNext;
454 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
455 1u, // uint32_t viewportCount;
456 &viewport, // dynamic state // const VkViewport* pViewports;
457 1u, // uint32_t scissorCount;
458 &scissor, // dynamic state // const VkRect2D* pScissors;
461 const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
463 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
464 DE_NULL, // const void* pNext;
465 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
466 VK_FALSE, // VkBool32 depthClampEnable;
467 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
468 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
469 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
470 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
471 VK_FALSE, // VkBool32 depthBiasEnable;
472 0.0f, // float depthBiasConstantFactor;
473 0.0f, // float depthBiasClamp;
474 0.0f, // float depthBiasSlopeFactor;
475 1.0f, // float lineWidth;
478 const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
480 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
481 DE_NULL, // const void* pNext;
482 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
483 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
484 VK_FALSE, // VkBool32 sampleShadingEnable;
485 0.0f, // float minSampleShading;
486 DE_NULL, // const VkSampleMask* pSampleMask;
487 VK_FALSE, // VkBool32 alphaToCoverageEnable;
488 VK_FALSE // VkBool32 alphaToOneEnable;
491 const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
492 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
494 VK_FALSE, // VkBool32 blendEnable;
495 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
496 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
497 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
498 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
499 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
500 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
501 colorComponentsAll, // VkColorComponentFlags colorWriteMask;
503 std::vector<VkPipelineColorBlendAttachmentState> colorAttachments(colorAttachmentCount, colorBlendAttachmentState);
505 const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
507 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
508 DE_NULL, // const void* pNext;
509 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
510 VK_FALSE, // VkBool32 logicOpEnable;
511 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
512 (deUint32)colorAttachments.size(), // deUint32 attachmentCount;
513 colorAttachments.size() != 0 ? &colorAttachments[0] : DE_NULL, // const VkPipelineColorBlendAttachmentState* pAttachments;
514 { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4];
517 const VkPipelineShaderStageCreateInfo pShaderStages[] =
520 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
521 DE_NULL, // const void* pNext;
522 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
523 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
524 vertexModule, // VkShaderModule module;
525 "main", // const char* pName;
526 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
529 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
530 DE_NULL, // const void* pNext;
531 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
532 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
533 fragmentModule, // VkShaderModule module;
534 "main", // const char* pName;
535 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
539 const deUint32 numActiveShaderStages = DE_LENGTH_OF_ARRAY(pShaderStages);
541 const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
543 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
544 DE_NULL, // const void* pNext;
545 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
546 numActiveShaderStages, // deUint32 stageCount;
547 pShaderStages, // const VkPipelineShaderStageCreateInfo* pStages;
548 &vertexInputStateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
549 &pipelineInputAssemblyStateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
550 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
551 &pipelineViewportStateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState;
552 &pipelineRasterizationStateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
553 &pipelineMultisampleStateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
554 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
555 &pipelineColorBlendStateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
556 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
557 pipelineLayout, // VkPipelineLayout layout;
558 renderPass, // VkRenderPass renderPass;
559 0u, // deUint32 subpass;
560 DE_NULL, // VkPipeline basePipelineHandle;
561 0, // deInt32 basePipelineIndex;
564 return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
567 //! A single-subpass render pass.
568 Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk,
569 const VkDevice device,
570 const VkFormat inputFormat,
571 const VkFormat colorFormat)
573 const VkAttachmentReference inputAttachmentRef =
575 0u, // deUint32 attachment;
576 VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout;
579 const VkAttachmentReference colorAttachmentRef =
581 1u, // deUint32 attachment;
582 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
585 const VkSubpassDescription subpassDescription =
587 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
588 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
589 1u, // deUint32 inputAttachmentCount;
590 &inputAttachmentRef, // const VkAttachmentReference* pInputAttachments;
591 1u, // deUint32 colorAttachmentCount;
592 &colorAttachmentRef, // const VkAttachmentReference* pColorAttachments;
593 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
594 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
595 0u, // deUint32 preserveAttachmentCount;
596 DE_NULL // const deUint32* pPreserveAttachments;
599 const VkAttachmentDescription attachmentsDescriptions[] =
601 //inputAttachmentDescription,
603 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
604 inputFormat, // VkFormat format;
605 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
606 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
607 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
608 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
609 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
610 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
611 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
613 //colorAttachmentDescription
615 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
616 colorFormat, // VkFormat format;
617 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
618 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
619 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
620 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
621 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
622 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
623 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
627 const VkRenderPassCreateInfo renderPassInfo =
629 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
630 DE_NULL, // const void* pNext;
631 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
632 DE_LENGTH_OF_ARRAY(attachmentsDescriptions), // deUint32 attachmentCount;
633 attachmentsDescriptions, // const VkAttachmentDescription* pAttachments;
634 1u, // deUint32 subpassCount;
635 &subpassDescription, // const VkSubpassDescription* pSubpasses;
636 0u, // deUint32 dependencyCount;
637 DE_NULL // const VkSubpassDependency* pDependencies;
640 return createRenderPass(vk, device, &renderPassInfo);
643 //! A single-subpass render pass.
644 Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk,
645 const VkDevice device)
647 const VkSubpassDescription subpassDescription =
649 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
650 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
651 0u, // deUint32 inputAttachmentCount;
652 DE_NULL, // const VkAttachmentReference* pInputAttachments;
653 0u, // deUint32 colorAttachmentCount;
654 DE_NULL, // const VkAttachmentReference* pColorAttachments;
655 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
656 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
657 0u, // deUint32 preserveAttachmentCount;
658 DE_NULL // const deUint32* pPreserveAttachments;
661 const VkRenderPassCreateInfo renderPassInfo =
663 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
664 DE_NULL, // const void* pNext;
665 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
666 0, // deUint32 attachmentCount;
667 DE_NULL, // const VkAttachmentDescription* pAttachments;
668 1u, // deUint32 subpassCount;
669 &subpassDescription, // const VkSubpassDescription* pSubpasses;
670 0u, // deUint32 dependencyCount;
671 DE_NULL // const VkSubpassDependency* pDependencies;
674 return createRenderPass(vk, device, &renderPassInfo);
677 Move<VkBufferView> makeBufferView (const DeviceInterface& vk,
678 const VkDevice vkDevice,
679 const VkBuffer buffer,
680 const VkFormat format,
681 const VkDeviceSize offset,
682 const VkDeviceSize size)
684 const VkBufferViewCreateInfo bufferViewParams =
686 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType;
687 DE_NULL, // const void* pNext;
688 0u, // VkBufferViewCreateFlags flags;
689 buffer, // VkBuffer buffer;
690 format, // VkFormat format;
691 offset, // VkDeviceSize offset;
692 size, // VkDeviceSize range;
694 return createBufferView(vk, vkDevice, &bufferViewParams);
697 Move<VkImageView> makeImageView (const DeviceInterface& vk,
698 const VkDevice vkDevice,
700 const VkImageViewType imageViewType,
701 const VkFormat format,
702 const VkImageSubresourceRange subresourceRange,
703 const VkImageViewUsageCreateInfoKHR* ImageUsageCreateInfoKHR)
705 const VkImageViewCreateInfo imageViewParams =
707 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
708 ImageUsageCreateInfoKHR, // const void* pNext;
709 0u, // VkImageViewCreateFlags flags;
710 image, // VkImage image;
711 imageViewType, // VkImageViewType viewType;
712 format, // VkFormat format;
713 makeComponentMappingRGBA(), // VkComponentMapping components;
714 subresourceRange, // VkImageSubresourceRange subresourceRange;
716 return createImageView(vk, vkDevice, &imageViewParams);
719 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface& vk,
720 const VkDevice device,
721 const VkDescriptorPool descriptorPool,
722 const VkDescriptorSetLayout setLayout)
724 const VkDescriptorSetAllocateInfo allocateParams =
726 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
727 DE_NULL, // const void* pNext;
728 descriptorPool, // VkDescriptorPool descriptorPool;
729 1u, // deUint32 setLayoutCount;
730 &setLayout, // const VkDescriptorSetLayout* pSetLayouts;
732 return allocateDescriptorSet(vk, device, &allocateParams);
735 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags srcAccessMask,
736 const VkAccessFlags dstAccessMask,
737 const VkBuffer buffer,
738 const VkDeviceSize offset,
739 const VkDeviceSize bufferSizeBytes)
741 const VkBufferMemoryBarrier barrier =
743 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
744 DE_NULL, // const void* pNext;
745 srcAccessMask, // VkAccessFlags srcAccessMask;
746 dstAccessMask, // VkAccessFlags dstAccessMask;
747 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
748 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
749 buffer, // VkBuffer buffer;
750 offset, // VkDeviceSize offset;
751 bufferSizeBytes, // VkDeviceSize size;
756 VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags srcAccessMask,
757 const VkAccessFlags dstAccessMask,
758 const VkImageLayout oldLayout,
759 const VkImageLayout newLayout,
761 const VkImageSubresourceRange subresourceRange)
763 const VkImageMemoryBarrier barrier =
765 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
766 DE_NULL, // const void* pNext;
767 srcAccessMask, // VkAccessFlags outputMask;
768 dstAccessMask, // VkAccessFlags inputMask;
769 oldLayout, // VkImageLayout oldLayout;
770 newLayout, // VkImageLayout newLayout;
771 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
772 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
773 image, // VkImage image;
774 subresourceRange, // VkImageSubresourceRange subresourceRange;
779 VkSamplerCreateInfo makeSamplerCreateInfo ()
781 const VkSamplerCreateInfo defaultSamplerParams =
783 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
784 DE_NULL, // const void* pNext;
785 0u, // VkSamplerCreateFlags flags;
786 VK_FILTER_NEAREST, // VkFilter magFilter;
787 VK_FILTER_NEAREST, // VkFilter minFilter;
788 VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode;
789 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU;
790 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV;
791 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW;
792 0.0f, // float mipLodBias;
793 VK_FALSE, // VkBool32 anisotropyEnable;
794 1.0f, // float maxAnisotropy;
795 false, // VkBool32 compareEnable;
796 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp;
797 0.0f, // float minLod;
798 0.25f, // float maxLod;
799 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor;
800 false // VkBool32 unnormalizedCoordinates;
803 return defaultSamplerParams;
806 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
808 const VkCommandBufferBeginInfo commandBufBeginParams =
810 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
811 DE_NULL, // const void* pNext;
812 0u, // VkCommandBufferUsageFlags flags;
813 (const VkCommandBufferInheritanceInfo*)DE_NULL,
815 VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufBeginParams));
817 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
819 VK_CHECK(vk.endCommandBuffer(commandBuffer));
822 void submitCommandsAndWait (const DeviceInterface& vk,
823 const VkDevice device,
825 const VkCommandBuffer commandBuffer)
827 const Unique<VkFence> fence(createFence(vk, device));
829 const VkSubmitInfo submitInfo =
831 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
832 DE_NULL, // const void* pNext;
833 0u, // deUint32 waitSemaphoreCount;
834 DE_NULL, // const VkSemaphore* pWaitSemaphores;
835 (const VkPipelineStageFlags*)DE_NULL,
836 1u, // deUint32 commandBufferCount;
837 &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
838 0u, // deUint32 signalSemaphoreCount;
839 DE_NULL, // const VkSemaphore* pSignalSemaphores;
842 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
843 VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
846 tcu::UVec3 getCompressedImageResolutionInBlocks(const vk::VkFormat format, const tcu::UVec3 size)
848 deUint32 blockWidth = getBlockWidth(format);
849 deUint32 blockHeight = getBlockHeight(format);
851 DE_ASSERT(size[2] == 1);
852 DE_ASSERT(blockWidth != 0 && blockHeight != 0);
854 deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth;
855 deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight;
857 return tcu::UVec3(widthInBlocks, heightInBlocks, 1);
860 VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
862 tcu::UVec3 sizeInBlocks = getCompressedImageResolutionInBlocks(format, size);
863 deUint32 blockBytes = getBlockSizeInBytes(format);
864 VkDeviceSize sizeBytes = sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes;
869 VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size)
871 const tcu::IVec3 sizeAsIVec3 = tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z());
872 const VkDeviceSize sizeBytes = getImageSizeBytes(sizeAsIVec3, format);
877 VkImageType mapImageType (const ImageType imageType)
882 case IMAGE_TYPE_1D_ARRAY:
883 case IMAGE_TYPE_BUFFER:
884 return VK_IMAGE_TYPE_1D;
887 case IMAGE_TYPE_2D_ARRAY:
888 case IMAGE_TYPE_CUBE:
889 case IMAGE_TYPE_CUBE_ARRAY:
890 return VK_IMAGE_TYPE_2D;
893 return VK_IMAGE_TYPE_3D;
897 return VK_IMAGE_TYPE_LAST;
901 VkImageViewType mapImageViewType (const ImageType imageType)
905 case IMAGE_TYPE_1D: return VK_IMAGE_VIEW_TYPE_1D;
906 case IMAGE_TYPE_1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
907 case IMAGE_TYPE_2D: return VK_IMAGE_VIEW_TYPE_2D;
908 case IMAGE_TYPE_2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
909 case IMAGE_TYPE_3D: return VK_IMAGE_VIEW_TYPE_3D;
910 case IMAGE_TYPE_CUBE: return VK_IMAGE_VIEW_TYPE_CUBE;
911 case IMAGE_TYPE_CUBE_ARRAY: return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
915 return VK_IMAGE_VIEW_TYPE_LAST;
919 std::string getImageTypeName (const ImageType imageType)
923 case IMAGE_TYPE_1D: return "1d";
924 case IMAGE_TYPE_1D_ARRAY: return "1d_array";
925 case IMAGE_TYPE_2D: return "2d";
926 case IMAGE_TYPE_2D_ARRAY: return "2d_array";
927 case IMAGE_TYPE_3D: return "3d";
928 case IMAGE_TYPE_CUBE: return "cube";
929 case IMAGE_TYPE_CUBE_ARRAY: return "cube_array";
930 case IMAGE_TYPE_BUFFER: return "buffer";
938 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample)
940 std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
941 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : "";
943 std::string imageTypePart;
948 case IMAGE_TYPE_2D: imageTypePart = "2DMS"; break;
949 case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DMSArray"; break;
959 case IMAGE_TYPE_1D: imageTypePart = "1D"; break;
960 case IMAGE_TYPE_1D_ARRAY: imageTypePart = "1DArray"; break;
961 case IMAGE_TYPE_2D: imageTypePart = "2D"; break;
962 case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DArray"; break;
963 case IMAGE_TYPE_3D: imageTypePart = "3D"; break;
964 case IMAGE_TYPE_CUBE: imageTypePart = "Cube"; break;
965 case IMAGE_TYPE_CUBE_ARRAY: imageTypePart = "CubeArray"; break;
966 case IMAGE_TYPE_BUFFER: imageTypePart = "Buffer"; break;
973 return formatPart + "image" + imageTypePart;
976 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
978 const char* orderPart;
979 const char* typePart;
981 switch (format.order)
983 case tcu::TextureFormat::R: orderPart = "r"; break;
984 case tcu::TextureFormat::RG: orderPart = "rg"; break;
985 case tcu::TextureFormat::RGB: orderPart = "rgb"; break;
986 case tcu::TextureFormat::RGBA: orderPart = "rgba"; break;
995 case tcu::TextureFormat::FLOAT: typePart = "32f"; break;
996 case tcu::TextureFormat::HALF_FLOAT: typePart = "16f"; break;
998 case tcu::TextureFormat::UNSIGNED_INT32: typePart = "32ui"; break;
999 case tcu::TextureFormat::UNSIGNED_INT16: typePart = "16ui"; break;
1000 case tcu::TextureFormat::UNSIGNED_INT8: typePart = "8ui"; break;
1002 case tcu::TextureFormat::SIGNED_INT32: typePart = "32i"; break;
1003 case tcu::TextureFormat::SIGNED_INT16: typePart = "16i"; break;
1004 case tcu::TextureFormat::SIGNED_INT8: typePart = "8i"; break;
1006 case tcu::TextureFormat::UNORM_INT16: typePart = "16"; break;
1007 case tcu::TextureFormat::UNORM_INT8: typePart = "8"; break;
1009 case tcu::TextureFormat::SNORM_INT16: typePart = "16_snorm"; break;
1010 case tcu::TextureFormat::SNORM_INT8: typePart = "8_snorm"; break;
1017 return std::string() + orderPart + typePart;
1020 std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type)
1022 const char* typePart = DE_NULL;
1023 const char* formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
1024 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : "";
1028 case VK_IMAGE_VIEW_TYPE_1D: typePart = "sampler1D"; break;
1029 case VK_IMAGE_VIEW_TYPE_1D_ARRAY: typePart = "sampler1DArray"; break;
1030 case VK_IMAGE_VIEW_TYPE_2D: typePart = "sampler2D"; break;
1031 case VK_IMAGE_VIEW_TYPE_2D_ARRAY: typePart = "sampler2DArray"; break;
1032 case VK_IMAGE_VIEW_TYPE_3D: typePart = "sampler3D"; break;
1033 case VK_IMAGE_VIEW_TYPE_CUBE: typePart = "samplerCube"; break;
1034 case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: typePart = "samplerCubeArray"; break;
1037 DE_FATAL("Unknown image view type");
1041 return std::string(formatPart) + typePart;
1045 const char* getGlslInputFormatType (const vk::VkFormat format)
1050 case VK_FORMAT_R16G16B16A16_UNORM: return "subpassInput";
1051 case VK_FORMAT_R16G16B16A16_SNORM: return "subpassInput";
1052 case VK_FORMAT_R16G16B16A16_USCALED: return "subpassInput";
1053 case VK_FORMAT_R16G16B16A16_SSCALED: return "subpassInput";
1054 case VK_FORMAT_R16G16B16A16_UINT: return "usubpassInput";
1055 case VK_FORMAT_R16G16B16A16_SINT: return "isubpassInput";
1056 case VK_FORMAT_R16G16B16A16_SFLOAT: return "subpassInput";
1057 case VK_FORMAT_R32G32_UINT: return "usubpassInput";
1058 case VK_FORMAT_R32G32_SINT: return "isubpassInput";
1059 case VK_FORMAT_R32G32_SFLOAT: return "subpassInput";
1060 // TODO: case VK_FORMAT_R64_UINT: return "usubpassInput";
1061 // TODO: case VK_FORMAT_R64_SINT: return "isubpassInput";
1062 // TODO: case VK_FORMAT_R64_SFLOAT: return "subpassInput";
1065 case VK_FORMAT_R32G32B32A32_UINT: return "usubpassInput";
1066 case VK_FORMAT_R32G32B32A32_SINT: return "isubpassInput";
1067 case VK_FORMAT_R32G32B32A32_SFLOAT: return "subpassInput";
1068 // TODO: case VK_FORMAT_R64G64_UINT: return "usubpassInput";
1069 // TODO: case VK_FORMAT_R64G64_SINT: return "isubpassInput";
1070 // TODO: case VK_FORMAT_R64G64_SFLOAT: return "subpassInput";
1072 default: TCU_THROW(InternalError, "Unknown format");
1076 const char* getGlslFormatType (const vk::VkFormat format)
1081 case VK_FORMAT_R16G16B16A16_UNORM: return "vec4";
1082 case VK_FORMAT_R16G16B16A16_SNORM: return "vec4";
1083 case VK_FORMAT_R16G16B16A16_USCALED: return "vec4";
1084 case VK_FORMAT_R16G16B16A16_SSCALED: return "vec4";
1085 case VK_FORMAT_R16G16B16A16_UINT: return "uvec4";
1086 case VK_FORMAT_R16G16B16A16_SINT: return "ivec4";
1087 case VK_FORMAT_R16G16B16A16_SFLOAT: return "vec4";
1088 case VK_FORMAT_R32G32_UINT: return "uvec2";
1089 case VK_FORMAT_R32G32_SINT: return "ivec2";
1090 case VK_FORMAT_R32G32_SFLOAT: return "vec2";
1091 // TODO: case VK_FORMAT_R64_UINT: return "uint64";
1092 // TODO: case VK_FORMAT_R64_SINT: return "int64";
1093 // TODO: case VK_FORMAT_R64_SFLOAT: return "double";
1096 case VK_FORMAT_R32G32B32A32_UINT: return "uvec4";
1097 case VK_FORMAT_R32G32B32A32_SINT: return "ivec4";
1098 case VK_FORMAT_R32G32B32A32_SFLOAT: return "vec4";
1099 // TODO: case VK_FORMAT_R64G64_UINT: return "ulvec2";
1100 // TODO: case VK_FORMAT_R64G64_SINT: return "ilvec2";
1101 // TODO: case VK_FORMAT_R64G64_SFLOAT: return "dvec2";
1103 default: TCU_THROW(InternalError, "Unknown format");
1107 std::string getFormatShortString (const VkFormat format)
1109 const std::string fullName = getFormatName(format);
1111 DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
1113 return de::toLower(fullName.substr(10));
1116 std::vector<tcu::Vec4> createFullscreenQuad (void)
1118 const tcu::Vec4 lowerLeftVertex (-1.0f, -1.0f, 0.0f, 1.0f);
1119 const tcu::Vec4 upperLeftVertex (-1.0f, 1.0f, 0.0f, 1.0f);
1120 const tcu::Vec4 lowerRightVertex (1.0f, -1.0f, 0.0f, 1.0f);
1121 const tcu::Vec4 upperRightVertex (1.0f, 1.0f, 0.0f, 1.0f);
1123 const tcu::Vec4 vertices[6] =
1134 return std::vector<tcu::Vec4>(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices));
1137 vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight)
1139 const VkBufferImageCopy copyParams =
1141 (VkDeviceSize)0u, // bufferOffset
1142 imageWidth, // bufferRowLength
1143 imageHeight, // bufferImageHeight
1145 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1147 0u, // baseArrayLayer
1149 }, // imageSubresource
1150 { 0u, 0u, 0u }, // imageOffset
1161 void beginRenderPass (const DeviceInterface& vk,
1162 const VkCommandBuffer commandBuffer,
1163 const VkRenderPass renderPass,
1164 const VkFramebuffer framebuffer,
1165 const VkExtent2D& renderSize)
1167 const VkClearValue clearValues[] =
1169 makeClearValueColorF32(0.0, 0.0, 0.0, 0.0),
1170 makeClearValueColorF32(0.0, 0.0, 0.0, 0.0),
1172 const VkRect2D renderArea =
1174 {0, 0}, // VkOffset2D offset;
1175 renderSize, // VkExtent2D extent;
1177 const VkRenderPassBeginInfo renderPassBeginInfo =
1179 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
1180 DE_NULL, // const void* pNext;
1181 renderPass, // VkRenderPass renderPass;
1182 framebuffer, // VkFramebuffer framebuffer;
1183 renderArea, // VkRect2D renderArea;
1184 DE_LENGTH_OF_ARRAY(clearValues), // uint32_t clearValueCount;
1185 clearValues, // const VkClearValue* pClearValues;
1188 vk.cmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
1191 Move<VkFramebuffer> makeFramebuffer (const DeviceInterface& vk,
1192 const VkDevice device,
1193 const VkRenderPass renderPass,
1194 const deUint32 attachmentCount,
1195 const VkImageView* pAttachments,
1196 const VkExtent2D& size,
1197 const deUint32 layersCount)
1199 const vk::VkFramebufferCreateInfo framebufferInfo =
1201 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
1202 DE_NULL, // const void* pNext;
1203 (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
1204 renderPass, // VkRenderPass renderPass;
1205 attachmentCount, // uint32_t attachmentCount;
1206 pAttachments, // const VkImageView* pAttachments;
1207 static_cast<deUint32>(size.width), // uint32_t width;
1208 static_cast<deUint32>(size.height), // uint32_t height;
1209 layersCount, // uint32_t layers;
1212 return createFramebuffer(vk, device, &framebufferInfo);