xref: /aosp_15_r20/external/deqp/external/vulkancts/modules/vulkan/multiview/vktMultiViewRenderUtil.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930) 
1 /*------------------------------------------------------------------------
2  * Vulkan Conformance Tests
3  * ------------------------
4  *
5  * Copyright (c) 2017 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 Vulkan Multi View Render Util
22  *//*--------------------------------------------------------------------*/
23 
24 #include "vktMultiViewRenderUtil.hpp"
25 #include "vktMultiViewRenderPassUtil.hpp"
26 
27 #include "vktTestCase.hpp"
28 #include "vkBuilderUtil.hpp"
29 #include "vkRefUtil.hpp"
30 #include "vkQueryUtil.hpp"
31 #include "vkTypeUtil.hpp"
32 #include "vkPrograms.hpp"
33 #include "vkPlatform.hpp"
34 #include "vkMemUtil.hpp"
35 #include "vkImageUtil.hpp"
36 
37 #include "tcuTestLog.hpp"
38 #include "tcuResource.hpp"
39 #include "tcuImageCompare.hpp"
40 #include "tcuCommandLine.hpp"
41 #include "tcuTextureUtil.hpp"
42 #include "tcuRGBA.hpp"
43 
44 namespace vkt
45 {
46 namespace MultiView
47 {
48 using namespace vk;
49 using de::MovePtr;
50 using de::UniquePtr;
51 using std::vector;
52 
getAspectFlags(tcu::TextureFormat format)53 VkImageAspectFlags getAspectFlags(tcu::TextureFormat format)
54 {
55     VkImageAspectFlags aspectFlag = 0;
56     aspectFlag |= (tcu::hasDepthComponent(format.order) ? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
57     aspectFlag |= (tcu::hasStencilComponent(format.order) ? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
58 
59     if (!aspectFlag)
60         aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
61 
62     return aspectFlag;
63 }
64 
getStencilBufferFormat(const vk::VkFormat depthStencilImageFormat)65 VkFormat getStencilBufferFormat(const vk::VkFormat depthStencilImageFormat)
66 {
67     const tcu::TextureFormat tcuFormat = mapVkFormat(depthStencilImageFormat);
68     const VkFormat result = (tcuFormat.order == tcu::TextureFormat::S || tcuFormat.order == tcu::TextureFormat::DS) ?
69                                 VK_FORMAT_S8_UINT :
70                                 VK_FORMAT_UNDEFINED;
71 
72     DE_ASSERT(result != VK_FORMAT_UNDEFINED);
73 
74     return result;
75 }
76 
getDepthBufferFormat(const vk::VkFormat depthStencilImageFormat)77 VkFormat getDepthBufferFormat(const vk::VkFormat depthStencilImageFormat)
78 {
79     VkFormat result = VK_FORMAT_UNDEFINED;
80 
81     switch (depthStencilImageFormat)
82     {
83     case VK_FORMAT_D16_UNORM:
84     case VK_FORMAT_D16_UNORM_S8_UINT:
85     {
86         result = VK_FORMAT_D16_UNORM;
87 
88         break;
89     }
90 
91     case VK_FORMAT_D32_SFLOAT:
92     case VK_FORMAT_D32_SFLOAT_S8_UINT:
93     {
94         result = VK_FORMAT_D32_SFLOAT;
95         break;
96     }
97 
98     case VK_FORMAT_X8_D24_UNORM_PACK32:
99     case VK_FORMAT_D24_UNORM_S8_UINT:
100     {
101         result = VK_FORMAT_D24_UNORM_S8_UINT;
102         break;
103     }
104 
105     default:
106         result = VK_FORMAT_UNDEFINED;
107     }
108 
109     DE_ASSERT(result != VK_FORMAT_UNDEFINED);
110 
111     return result;
112 }
113 
makeImageCreateInfo(const VkImageType imageType,const VkExtent3D & extent,const VkFormat format,const VkImageUsageFlags usage,const VkSampleCountFlagBits samples)114 VkImageCreateInfo makeImageCreateInfo(const VkImageType imageType, const VkExtent3D &extent, const VkFormat format,
115                                       const VkImageUsageFlags usage, const VkSampleCountFlagBits samples)
116 {
117     const VkImageCreateInfo imageInfo = {
118         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
119         DE_NULL,                             // const void* pNext;
120         (VkImageCreateFlags)0,               // VkImageCreateFlags flags;
121         imageType,                           // VkImageType imageType;
122         format,                              // VkFormat format;
123         {extent.width, extent.height, 1u},   // VkExtent3D extent;
124         1u,                                  // uint32_t mipLevels;
125         extent.depth,                        // uint32_t arrayLayers;
126         samples,                             // VkSampleCountFlagBits samples;
127         VK_IMAGE_TILING_OPTIMAL,             // VkImageTiling tiling;
128         usage,                               // VkImageUsageFlags usage;
129         VK_SHARING_MODE_EXCLUSIVE,           // VkSharingMode sharingMode;
130         0u,                                  // uint32_t queueFamilyIndexCount;
131         DE_NULL,                             // const uint32_t* pQueueFamilyIndices;
132         VK_IMAGE_LAYOUT_UNDEFINED,           // VkImageLayout initialLayout;
133     };
134     return imageInfo;
135 }
136 
makeDescriptorSetLayout(const DeviceInterface & vk,const VkDevice device)137 Move<VkDescriptorSetLayout> makeDescriptorSetLayout(const DeviceInterface &vk, const VkDevice device)
138 {
139     const VkDescriptorSetLayoutBinding binding = {
140         0u,                                      //uint32_t binding;
141         vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, //VkDescriptorType descriptorType;
142         1u,                                      //uint32_t descriptorCount;
143         vk::VK_SHADER_STAGE_FRAGMENT_BIT,        //VkShaderStageFlags stageFlags;
144         DE_NULL                                  //const VkSampler* pImmutableSamplers;
145     };
146 
147     const VkDescriptorSetLayoutCreateInfo createInfo = {
148         vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, //VkStructureType sType;
149         DE_NULL,                                                 //const void* pNext;
150         0u,                                                      //VkDescriptorSetLayoutCreateFlags flags;
151         1u,                                                      //uint32_t bindingCount;
152         &binding                                                 //const VkDescriptorSetLayoutBinding* pBindings;
153     };
154     return vk::createDescriptorSetLayout(vk, device, &createInfo);
155 }
156 
157 template <typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep,
158           typename RenderPassCreateInfo>
makeRenderPass(const DeviceInterface & vk,const VkDevice device,const VkFormat colorFormat,const vector<uint32_t> & viewMasks,const VkSampleCountFlagBits samples,const VkAttachmentLoadOp colorLoadOp,const VkFormat dsFormat)159 Move<VkRenderPass> makeRenderPass(const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat,
160                                   const vector<uint32_t> &viewMasks, const VkSampleCountFlagBits samples,
161                                   const VkAttachmentLoadOp colorLoadOp, const VkFormat dsFormat)
162 {
163     const bool dsAttacmentAvailable = (dsFormat != vk::VK_FORMAT_UNDEFINED);
164     const uint32_t subpassCount     = static_cast<uint32_t>(viewMasks.size());
165     const AttachmentDesc
166         colorAttachmentDescription // VkAttachmentDescription                                        ||  VkAttachmentDescription2KHR
167         (
168             //  ||  VkStructureType sType;
169             DE_NULL,                         //   ||  const void* pNext;
170             (VkAttachmentDescriptionFlags)0, //  VkAttachmentDescriptionFlags flags; ||  VkAttachmentDescriptionFlags flags;
171             colorFormat,                     //  VkFormat format; ||  VkFormat format;
172             samples,                         //  VkSampleCountFlagBits samples; ||  VkSampleCountFlagBits samples;
173             colorLoadOp,                     //  VkAttachmentLoadOp loadOp; ||  VkAttachmentLoadOp loadOp;
174             VK_ATTACHMENT_STORE_OP_STORE,    //  VkAttachmentStoreOp storeOp; ||  VkAttachmentStoreOp storeOp;
175             VK_ATTACHMENT_LOAD_OP_DONT_CARE, //  VkAttachmentLoadOp stencilLoadOp; ||  VkAttachmentLoadOp stencilLoadOp;
176             VK_ATTACHMENT_STORE_OP_DONT_CARE, //  VkAttachmentStoreOp stencilStoreOp; ||  VkAttachmentStoreOp stencilStoreOp;
177             VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, //  VkImageLayout initialLayout; ||  VkImageLayout initialLayout;
178             VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL  //  VkImageLayout finalLayout; ||  VkImageLayout finalLayout;
179         );
180 
181     const AttachmentRef
182         colorAttachmentReference //  VkAttachmentReference                                        ||  VkAttachmentReference2KHR
183         (
184             //  ||  VkStructureType sType;
185             DE_NULL,                                  //   ||  const void* pNext;
186             0u,                                       //  uint32_t attachment; ||  uint32_t attachment;
187             VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, //  VkImageLayout layout; ||  VkImageLayout layout;
188             0u                                        // ||  VkImageAspectFlags aspectMask;
189         );
190 
191     const AttachmentDesc
192         dsAttachmentDescription //  VkAttachmentDescription                                        ||  VkAttachmentDescription2KHR
193         (
194             //  ||  VkStructureType sType;
195             DE_NULL,                         //   ||  const void* pNext;
196             (VkAttachmentDescriptionFlags)0, //  VkAttachmentDescriptionFlags flags; ||  VkAttachmentDescriptionFlags flags;
197             dsFormat,                        //  VkFormat format; ||  VkFormat format;
198             samples,                         //  VkSampleCountFlagBits samples; ||  VkSampleCountFlagBits samples;
199             VK_ATTACHMENT_LOAD_OP_LOAD,      //  VkAttachmentLoadOp loadOp; ||  VkAttachmentLoadOp loadOp;
200             VK_ATTACHMENT_STORE_OP_STORE, //  VkAttachmentStoreOp storeOp; ||  VkAttachmentStoreOp storeOp;
201             VK_ATTACHMENT_LOAD_OP_LOAD,   //  VkAttachmentLoadOp stencilLoadOp; ||  VkAttachmentLoadOp stencilLoadOp;
202             VK_ATTACHMENT_STORE_OP_STORE, //  VkAttachmentStoreOp stencilStoreOp; ||  VkAttachmentStoreOp stencilStoreOp;
203             VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, //  VkImageLayout initialLayout; ||  VkImageLayout initialLayout;
204             VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL //  VkImageLayout finalLayout; ||  VkImageLayout finalLayout;
205         );
206 
207     const AttachmentRef
208         depthAttachmentReference //  VkAttachmentReference                                        ||  VkAttachmentReference2KHR
209         (
210             //  ||  VkStructureType sType;
211             DE_NULL,                                          //   ||  const void* pNext;
212             dsAttacmentAvailable ? 1u : VK_ATTACHMENT_UNUSED, //  uint32_t attachment; ||  uint32_t attachment;
213             dsAttacmentAvailable ?                            //  VkImageLayout layout; ||  VkImageLayout layout;
214                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL :
215                 VK_IMAGE_LAYOUT_UNDEFINED,
216             0u // ||  VkImageAspectFlags aspectMask;
217         );
218 
219     const AttachmentDesc attachmentDescriptions[] = {
220         colorAttachmentDescription,
221         dsAttachmentDescription,
222     };
223 
224     DE_ASSERT((typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo1)) ||
225               (typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo2)));
226 
227     vector<SubpassDesc> subpassDescriptions;
228     for (uint32_t subpassNdx = 0; subpassNdx < subpassCount; ++subpassNdx)
229     {
230         const uint32_t viewMask =
231             (typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo2)) ? viewMasks[subpassNdx] : 0u;
232         const SubpassDesc
233             subpassDescription //  VkSubpassDescription                                        ||  VkSubpassDescription2KHR
234             (
235                 //  ||  VkStructureType sType;
236                 DE_NULL,                      //   ||  const void* pNext;
237                 (VkSubpassDescriptionFlags)0, //  VkSubpassDescriptionFlags flags; ||  VkSubpassDescriptionFlags flags;
238                 VK_PIPELINE_BIND_POINT_GRAPHICS, //  VkPipelineBindPoint pipelineBindPoint; ||  VkPipelineBindPoint pipelineBindPoint;
239                 viewMask,                        //   ||  uint32_t viewMask;
240                 0u,                              //  uint32_t inputAttachmentCount; ||  uint32_t inputAttachmentCount;
241                 DE_NULL, //  const VkAttachmentReference* pInputAttachments; ||  const VkAttachmentReference2KHR* pInputAttachments;
242                 1u, //  uint32_t colorAttachmentCount; ||  uint32_t colorAttachmentCount;
243                 &colorAttachmentReference, //  const VkAttachmentReference* pColorAttachments; ||  const VkAttachmentReference2KHR* pColorAttachments;
244                 DE_NULL, //  const VkAttachmentReference* pResolveAttachments; ||  const VkAttachmentReference2KHR* pResolveAttachments;
245                 &depthAttachmentReference, //  const VkAttachmentReference* pDepthStencilAttachment; ||  const VkAttachmentReference2KHR* pDepthStencilAttachment;
246                 0u,     //  uint32_t preserveAttachmentCount; ||  uint32_t preserveAttachmentCount;
247                 DE_NULL //  const uint32_t* pPreserveAttachments; ||  const uint32_t* pPreserveAttachments;
248             );
249 
250         subpassDescriptions.push_back(subpassDescription);
251     }
252 
253     const VkRenderPassMultiviewCreateInfo renderPassMultiviewInfo = {
254         VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, // VkStructureType sType;
255         DE_NULL,                                             // const void* pNext;
256         subpassCount,                                        // uint32_t subpassCount;
257         &viewMasks[0],                                       // const uint32_t* pViewMasks;
258         0u,                                                  // uint32_t dependencyCount;
259         DE_NULL,                                             // const int32_t* pViewOffsets;
260         0u,                                                  // uint32_t correlationMaskCount;
261         DE_NULL,                                             // const uint32_t* pCorrelationMasks;
262     };
263     const VkRenderPassMultiviewCreateInfo *renderPassMultiviewInfoPtr =
264         (typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo1)) ? &renderPassMultiviewInfo : DE_NULL;
265 
266     const VkPipelineStageFlags srcStageMask = dsAttacmentAvailable ? VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT :
267                                                                      VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
268     const VkAccessFlags srcAccessMask =
269         dsAttacmentAvailable ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT : VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
270     vector<SubpassDep> subpassDependencies;
271     for (uint32_t subpassNdx = 0u; subpassNdx < subpassCount; ++subpassNdx)
272     {
273         const auto dependencyFlags = (subpassNdx == subpassCount - 1u) ?
274                                          (VK_DEPENDENCY_BY_REGION_BIT | VK_DEPENDENCY_VIEW_LOCAL_BIT) :
275                                          VK_DEPENDENCY_VIEW_LOCAL_BIT;
276 
277         const SubpassDep
278             subpassDependency //  VkSubpassDependency                                            ||  VkSubpassDependency2KHR
279             (
280                 //  || VkStructureType sType;
281                 DE_NULL,    //   || const void* pNext;
282                 subpassNdx, //  uint32_t srcSubpass; || uint32_t srcSubpass;
283                 (subpassNdx == subpassCount - 1u) ? subpassNdx :
284                                                     subpassNdx + 1u, //  uint32_t dstSubpass; || uint32_t dstSubpass;
285                 srcStageMask, //  VkPipelineStageFlags srcStageMask; || VkPipelineStageFlags srcStageMask;
286                 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, //  VkPipelineStageFlags dstStageMask; || VkPipelineStageFlags dstStageMask;
287                 srcAccessMask,                         //  VkAccessFlags srcAccessMask; || VkAccessFlags srcAccessMask;
288                 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, //  VkAccessFlags dstAccessMask; || VkAccessFlags dstAccessMask;
289                 dependencyFlags, //  VkDependencyFlags dependencyFlags; || VkDependencyFlags dependencyFlags;
290                 0                //    || int32_t viewOffset;
291             );
292         subpassDependencies.push_back(subpassDependency);
293     }
294 
295     const RenderPassCreateInfo
296         renderPassInfo //  VkRenderPassCreateInfo                                        ||  VkRenderPassCreateInfo2KHR
297         (
298             //  VkStructureType sType; ||  VkStructureType sType;
299             renderPassMultiviewInfoPtr,     //  const void* pNext; ||  const void* pNext;
300             (VkRenderPassCreateFlags)0,     //  VkRenderPassCreateFlags flags; ||  VkRenderPassCreateFlags flags;
301             dsAttacmentAvailable ? 2u : 1u, //  uint32_t attachmentCount; ||  uint32_t attachmentCount;
302             attachmentDescriptions, //  const VkAttachmentDescription* pAttachments; ||  const VkAttachmentDescription2KHR* pAttachments;
303             subpassCount, //  uint32_t subpassCount; ||  uint32_t subpassCount;
304             &subpassDescriptions
305                 [0],      //  const VkSubpassDescription* pSubpasses; ||  const VkSubpassDescription2KHR* pSubpasses;
306             subpassCount, //  uint32_t dependencyCount; ||  uint32_t dependencyCount;
307             &subpassDependencies
308                 [0], //  const VkSubpassDependency* pDependencies; ||  const VkSubpassDependency2KHR* pDependencies;
309             0u,      //   ||  uint32_t correlatedViewMaskCount;
310             DE_NULL  //  ||  const uint32_t* pCorrelatedViewMasks;
311         );
312 
313     return renderPassInfo.createRenderPass(vk, device);
314 }
315 
316 // Instantiate function for legacy renderpass structures
317 template Move<VkRenderPass> makeRenderPass<AttachmentDescription1, AttachmentReference1, SubpassDescription1,
318                                            SubpassDependency1, RenderPassCreateInfo1>(
319     const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat, const vector<uint32_t> &viewMasks,
320     const VkSampleCountFlagBits samples, const VkAttachmentLoadOp colorLoadOp, const VkFormat dsFormat);
321 
322 // Instantiate function for renderpass2 structures
323 template Move<VkRenderPass> makeRenderPass<AttachmentDescription2, AttachmentReference2, SubpassDescription2,
324                                            SubpassDependency2, RenderPassCreateInfo2>(
325     const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat, const vector<uint32_t> &viewMasks,
326     const VkSampleCountFlagBits samples, const VkAttachmentLoadOp colorLoadOp, const VkFormat dsFormat);
327 
328 template <typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep,
329           typename RenderPassCreateInfo>
makeRenderPassWithDepth(const DeviceInterface & vk,const VkDevice device,const VkFormat colorFormat,const vector<uint32_t> & viewMasks,const VkFormat dsFormat)330 Move<VkRenderPass> makeRenderPassWithDepth(const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat,
331                                            const vector<uint32_t> &viewMasks, const VkFormat dsFormat)
332 {
333     return makeRenderPass<AttachmentDesc, AttachmentRef, SubpassDesc, SubpassDep, RenderPassCreateInfo>(
334         vk, device, colorFormat, viewMasks, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_CLEAR, dsFormat);
335 }
336 
337 // Instantiate function for legacy renderpass structures
338 template Move<VkRenderPass> makeRenderPassWithDepth<AttachmentDescription1, AttachmentReference1, SubpassDescription1,
339                                                     SubpassDependency1, RenderPassCreateInfo1>(
340     const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat, const vector<uint32_t> &viewMasks,
341     const VkFormat dsFormat);
342 
343 // Instantiate function for renderpass2 structures
344 template Move<VkRenderPass> makeRenderPassWithDepth<AttachmentDescription2, AttachmentReference2, SubpassDescription2,
345                                                     SubpassDependency2, RenderPassCreateInfo2>(
346     const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat, const vector<uint32_t> &viewMasks,
347     const VkFormat dsFormat);
348 
349 template <typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep,
350           typename RenderPassCreateInfo>
makeRenderPassWithAttachments(const DeviceInterface & vk,const VkDevice device,const VkFormat colorFormat,const vector<uint32_t> & viewMasks,bool useAspects)351 Move<VkRenderPass> makeRenderPassWithAttachments(const DeviceInterface &vk, const VkDevice device,
352                                                  const VkFormat colorFormat, const vector<uint32_t> &viewMasks,
353                                                  bool useAspects)
354 {
355     const uint32_t subpassCount = static_cast<uint32_t>(viewMasks.size());
356 
357     const AttachmentDesc
358         colorAttachmentDescription //  VkAttachmentDescription                                        ||  VkAttachmentDescription2KHR
359         (
360             //  ||  VkStructureType sType;
361             DE_NULL,                         //   ||  const void* pNext;
362             (VkAttachmentDescriptionFlags)0, //  VkAttachmentDescriptionFlags flags; ||  VkAttachmentDescriptionFlags flags;
363             colorFormat,                     //  VkFormat format; ||  VkFormat format;
364             VK_SAMPLE_COUNT_1_BIT,           //  VkSampleCountFlagBits samples; ||  VkSampleCountFlagBits samples;
365             VK_ATTACHMENT_LOAD_OP_CLEAR,     //  VkAttachmentLoadOp loadOp; ||  VkAttachmentLoadOp loadOp;
366             VK_ATTACHMENT_STORE_OP_STORE,    //  VkAttachmentStoreOp storeOp; ||  VkAttachmentStoreOp storeOp;
367             VK_ATTACHMENT_LOAD_OP_DONT_CARE, //  VkAttachmentLoadOp stencilLoadOp; ||  VkAttachmentLoadOp stencilLoadOp;
368             VK_ATTACHMENT_STORE_OP_DONT_CARE, //  VkAttachmentStoreOp stencilStoreOp; ||  VkAttachmentStoreOp stencilStoreOp;
369             VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, //  VkImageLayout initialLayout; ||  VkImageLayout initialLayout;
370             VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL  //  VkImageLayout finalLayout; ||  VkImageLayout finalLayout;
371         );
372 
373     const AttachmentDesc
374         inputAttachmentDescription //  VkAttachmentDescription                                        ||  VkAttachmentDescription2KHR
375         (
376             //  ||  VkStructureType sType;
377             DE_NULL,                         //   ||  const void* pNext;
378             (VkAttachmentDescriptionFlags)0, //  VkAttachmentDescriptionFlags flags; ||  VkAttachmentDescriptionFlags flags;
379             colorFormat,                     //  VkFormat format; ||  VkFormat format;
380             VK_SAMPLE_COUNT_1_BIT,           //  VkSampleCountFlagBits samples; ||  VkSampleCountFlagBits samples;
381             VK_ATTACHMENT_LOAD_OP_LOAD,      //  VkAttachmentLoadOp loadOp; ||  VkAttachmentLoadOp loadOp;
382             VK_ATTACHMENT_STORE_OP_STORE,    //  VkAttachmentStoreOp storeOp; ||  VkAttachmentStoreOp storeOp;
383             VK_ATTACHMENT_LOAD_OP_DONT_CARE, //  VkAttachmentLoadOp stencilLoadOp; ||  VkAttachmentLoadOp stencilLoadOp;
384             VK_ATTACHMENT_STORE_OP_DONT_CARE, //  VkAttachmentStoreOp stencilStoreOp; ||  VkAttachmentStoreOp stencilStoreOp;
385             VK_IMAGE_LAYOUT_GENERAL,          //  VkImageLayout initialLayout; ||  VkImageLayout initialLayout;
386             VK_IMAGE_LAYOUT_GENERAL           //  VkImageLayout finalLayout; ||  VkImageLayout finalLayout;
387         );
388 
389     vector<AttachmentDesc> attachments;
390     attachments.push_back(colorAttachmentDescription);
391     attachments.push_back(inputAttachmentDescription);
392 
393     const AttachmentRef
394         colorAttachmentReference //  VkAttachmentReference                                        ||  VkAttachmentReference2KHR
395         (
396             //  ||  VkStructureType sType;
397             DE_NULL,                                  //   ||  const void* pNext;
398             0u,                                       //  uint32_t attachment; ||  uint32_t attachment;
399             VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, //  VkImageLayout layout; ||  VkImageLayout layout;
400             0u                                        // ||  VkImageAspectFlags aspectMask;
401         );
402 
403     const AttachmentRef
404         inputAttachmentReference //  VkAttachmentReference                                        ||  VkAttachmentReference2KHR
405         (
406             //  ||  VkStructureType sType;
407             DE_NULL,                 //   ||  const void* pNext;
408             1u,                      //  uint32_t attachment; ||  uint32_t attachment;
409             VK_IMAGE_LAYOUT_GENERAL, //  VkImageLayout layout; ||  VkImageLayout layout;
410             useAspects ? VK_IMAGE_ASPECT_COLOR_BIT :
411                          static_cast<VkImageAspectFlagBits>(0u) // ||  VkImageAspectFlags aspectMask;
412         );
413 
414     const AttachmentRef
415         depthAttachmentReference //  VkAttachmentReference                                        ||  VkAttachmentReference2KHR
416         (
417             //  ||  VkStructureType sType;
418             DE_NULL,                   //   ||  const void* pNext;
419             VK_ATTACHMENT_UNUSED,      //  uint32_t attachment; ||  uint32_t attachment;
420             VK_IMAGE_LAYOUT_UNDEFINED, //  VkImageLayout layout; ||  VkImageLayout layout;
421             0u                         // ||  VkImageAspectFlags aspectMask;
422         );
423 
424     DE_ASSERT((typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo1)) ||
425               (typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo2)));
426 
427     vector<SubpassDesc> subpassDescriptions;
428     for (uint32_t subpassNdx = 0; subpassNdx < subpassCount; ++subpassNdx)
429     {
430         const uint32_t viewMask =
431             (typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo2)) ? viewMasks[subpassNdx] : 0u;
432         const SubpassDesc
433             subpassDescription //  VkSubpassDescription                                        ||  VkSubpassDescription2KHR
434             (
435                 //  ||  VkStructureType sType;
436                 DE_NULL,                      //   ||  const void* pNext;
437                 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags; ||  VkSubpassDescriptionFlags flags;
438                 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; ||  VkPipelineBindPoint pipelineBindPoint;
439                 viewMask,                        //   ||  uint32_t viewMask;
440                 1u,                              // uint32_t inputAttachmentCount; ||  uint32_t inputAttachmentCount;
441                 &inputAttachmentReference, // const VkAttachmentReference* pInputAttachments; ||  const VkAttachmentReference2KHR* pInputAttachments;
442                 1u, // uint32_t colorAttachmentCount; ||  uint32_t colorAttachmentCount;
443                 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments; ||  const VkAttachmentReference2KHR* pColorAttachments;
444                 DE_NULL, // const VkAttachmentReference* pResolveAttachments; ||  const VkAttachmentReference2KHR* pResolveAttachments;
445                 &depthAttachmentReference, // const VkAttachmentReference* pDepthStencilAttachment; ||  const VkAttachmentReference2KHR* pDepthStencilAttachment;
446                 0u,     // uint32_t preserveAttachmentCount; ||  uint32_t preserveAttachmentCount;
447                 DE_NULL // const uint32_t* pPreserveAttachments; ||  const uint32_t* pPreserveAttachments;
448             );
449         subpassDescriptions.push_back(subpassDescription);
450     }
451 
452     const VkRenderPassMultiviewCreateInfo renderPassMultiviewInfo = {
453         VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, //VkStructureType sType;
454         DE_NULL,                                             //const void* pNext;
455         subpassCount,                                        //uint32_t subpassCount;
456         &viewMasks[0],                                       //const uint32_t* pViewMasks;
457         0u,                                                  //uint32_t dependencyCount;
458         DE_NULL,                                             //const int32_t* pViewOffsets;
459         0u,                                                  //uint32_t correlationMaskCount;
460         DE_NULL,                                             //const uint32_t* pCorrelationMasks;
461     };
462     const VkRenderPassMultiviewCreateInfo *renderPassMultiviewInfoPtr =
463         typeid(RenderPassCreateInfo) == typeid(RenderPassCreateInfo1) ? &renderPassMultiviewInfo : DE_NULL;
464 
465     vector<SubpassDep> subpassDependencies;
466     for (uint32_t subpassNdx = 0u; subpassNdx < subpassCount; ++subpassNdx)
467     {
468         const auto dependencyFlags = (subpassNdx == subpassCount - 1u) ?
469                                          (VK_DEPENDENCY_BY_REGION_BIT | VK_DEPENDENCY_VIEW_LOCAL_BIT) :
470                                          VK_DEPENDENCY_VIEW_LOCAL_BIT;
471 
472         const SubpassDep
473             subpassDependency //  VkSubpassDependency                                            ||  VkSubpassDependency2KHR
474             (
475                 //  || VkStructureType sType;
476                 DE_NULL,    //   || const void* pNext;
477                 subpassNdx, //  uint32_t srcSubpass; || uint32_t srcSubpass;
478                 (subpassNdx == subpassCount - 1u) ? subpassNdx :
479                                                     subpassNdx + 1u, //  uint32_t dstSubpass; || uint32_t dstSubpass;
480                 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, //  VkPipelineStageFlags srcStageMask; || VkPipelineStageFlags srcStageMask;
481                 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, //  VkPipelineStageFlags dstStageMask; || VkPipelineStageFlags dstStageMask;
482                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, //  VkAccessFlags srcAccessMask; || VkAccessFlags srcAccessMask;
483                 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,  //  VkAccessFlags dstAccessMask; || VkAccessFlags dstAccessMask;
484                 dependencyFlags, //  VkDependencyFlags dependencyFlags; || VkDependencyFlags dependencyFlags;
485                 0                //    || int32_t viewOffset;
486             );
487         subpassDependencies.push_back(subpassDependency);
488     }
489 
490     const RenderPassCreateInfo
491         renderPassInfo //  VkRenderPassCreateInfo                                        ||  VkRenderPassCreateInfo2KHR
492         (
493             //  VkStructureType sType; ||  VkStructureType sType;
494             renderPassMultiviewInfoPtr, //  const void* pNext; ||  const void* pNext;
495             (VkRenderPassCreateFlags)0, //  VkRenderPassCreateFlags flags; ||  VkRenderPassCreateFlags flags;
496             2u,                         //  uint32_t attachmentCount; ||  uint32_t attachmentCount;
497             &attachments
498                 [0], //  const VkAttachmentDescription* pAttachments; ||  const VkAttachmentDescription2KHR* pAttachments;
499             subpassCount, //  uint32_t subpassCount; ||  uint32_t subpassCount;
500             &subpassDescriptions
501                 [0],      //  const VkSubpassDescription* pSubpasses; ||  const VkSubpassDescription2KHR* pSubpasses;
502             subpassCount, //  uint32_t dependencyCount; ||  uint32_t dependencyCount;
503             &subpassDependencies
504                 [0], //  const VkSubpassDependency* pDependencies; ||  const VkSubpassDependency2KHR* pDependencies;
505             0u,      //   ||  uint32_t correlatedViewMaskCount;
506             DE_NULL  //  ||  const uint32_t* pCorrelatedViewMasks;
507         );
508 
509     return renderPassInfo.createRenderPass(vk, device);
510 }
511 
512 // Instantiate function for legacy renderpass structures
513 template Move<VkRenderPass> makeRenderPassWithAttachments<
514     AttachmentDescription1, AttachmentReference1, SubpassDescription1, SubpassDependency1, RenderPassCreateInfo1>(
515     const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat, const vector<uint32_t> &viewMasks,
516     bool useAspects);
517 
518 // Instantiate function for renderpass2 structures
519 template Move<VkRenderPass> makeRenderPassWithAttachments<
520     AttachmentDescription2, AttachmentReference2, SubpassDescription2, SubpassDependency2, RenderPassCreateInfo2>(
521     const DeviceInterface &vk, const VkDevice device, const VkFormat colorFormat, const vector<uint32_t> &viewMasks,
522     bool useAspects);
523 
beginSecondaryCommandBuffer(const DeviceInterface & vk,const VkCommandBuffer commandBuffer,const VkRenderPass renderPass,const uint32_t subpass,const VkFramebuffer framebuffer)524 void beginSecondaryCommandBuffer(const DeviceInterface &vk, const VkCommandBuffer commandBuffer,
525                                  const VkRenderPass renderPass, const uint32_t subpass, const VkFramebuffer framebuffer)
526 {
527     const VkCommandBufferInheritanceInfo secCmdBufInheritInfo = {
528         VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, //VkStructureType sType;
529         DE_NULL,                                           //const void* pNext;
530         renderPass,                                        //VkRenderPass renderPass;
531         subpass,                                           //uint32_t subpass;
532         framebuffer,                                       //VkFramebuffer framebuffer;
533         VK_FALSE,                                          //VkBool32 occlusionQueryEnable;
534         (VkQueryControlFlags)0u,                           //VkQueryControlFlags queryFlags;
535         (VkQueryPipelineStatisticFlags)0u,                 //VkQueryPipelineStatisticFlags pipelineStatistics;
536     };
537 
538     const VkCommandBufferBeginInfo info = {
539         VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,      // VkStructureType sType;
540         DE_NULL,                                          // const void* pNext;
541         VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, // VkCommandBufferUsageFlags flags;
542         &secCmdBufInheritInfo,                            // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
543     };
544     VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
545 }
546 
imageBarrier(const DeviceInterface & vk,const VkCommandBuffer cmdBuffer,const VkImage image,const VkImageSubresourceRange subresourceRange,const VkImageLayout oldLayout,const VkImageLayout newLayout,const VkAccessFlags srcAccessMask,const VkAccessFlags dstAccessMask,const VkPipelineStageFlags srcStageMask,const VkPipelineStageFlags dstStageMask)547 void imageBarrier(const DeviceInterface &vk, const VkCommandBuffer cmdBuffer, const VkImage image,
548                   const VkImageSubresourceRange subresourceRange, const VkImageLayout oldLayout,
549                   const VkImageLayout newLayout, const VkAccessFlags srcAccessMask, const VkAccessFlags dstAccessMask,
550                   const VkPipelineStageFlags srcStageMask, const VkPipelineStageFlags dstStageMask)
551 {
552     const VkImageMemoryBarrier barrier = {
553         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
554         DE_NULL,                                // const void* pNext;
555         srcAccessMask,                          // VkAccessFlags srcAccessMask;
556         dstAccessMask,                          // VkAccessFlags dstAccessMask;
557         oldLayout,                              // VkImageLayout oldLayout;
558         newLayout,                              // VkImageLayout newLayout;
559         VK_QUEUE_FAMILY_IGNORED,                // uint32_t srcQueueFamilyIndex;
560         VK_QUEUE_FAMILY_IGNORED,                // uint32_t dstQueueFamilyIndex;
561         image,                                  // VkImage image;
562         subresourceRange,                       // VkImageSubresourceRange subresourceRange;
563     };
564 
565     vk.cmdPipelineBarrier(cmdBuffer, srcStageMask, dstStageMask, (VkDependencyFlags)0, 0u,
566                           (const VkMemoryBarrier *)DE_NULL, 0u, (const VkBufferMemoryBarrier *)DE_NULL, 1u, &barrier);
567 }
568 
569 } // namespace MultiView
570 } // namespace vkt
571