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