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