xref: /aosp_15_r20/external/deqp/external/vulkancts/modules/vulkan/renderpass/vktRenderPassTestsUtil.hpp (revision 35238bce31c2a825756842865a792f8cf7f89930) 
1 #ifndef _VKTRENDERPASSTESTSUTIL_HPP
2 #define _VKTRENDERPASSTESTSUTIL_HPP
3 /*------------------------------------------------------------------------
4  * Vulkan Conformance Tests
5  * ------------------------
6  *
7  * Copyright (c) 2018 The Khronos Group Inc.
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief RenderPass test utils
24  *//*--------------------------------------------------------------------*/
25 
26 #include "tcuDefs.hpp"
27 #include "vkRef.hpp"
28 #include "vkDefs.hpp"
29 #include "vkMemUtil.hpp"
30 #include "vkTypeUtil.hpp"
31 #include "vkTypeUtil.hpp"
32 #include "vktRenderPassGroupParams.hpp"
33 
34 #include <vector>
35 
36 namespace vkt
37 {
38 namespace renderpass
39 {
40 
41 using namespace vk;
42 
43 class AttachmentDescription1 : public vk::VkAttachmentDescription
44 {
45 public:
46     AttachmentDescription1(const void *pNext, VkAttachmentDescriptionFlags flags, VkFormat format,
47                            VkSampleCountFlagBits samples, VkAttachmentLoadOp loadOp, VkAttachmentStoreOp storeOp,
48                            VkAttachmentLoadOp stencilLoadOp, VkAttachmentStoreOp stencilStoreOp,
49                            VkImageLayout initialLayout, VkImageLayout finalLayout);
50 };
51 
52 class AttachmentDescription2 : public vk::VkAttachmentDescription2
53 {
54 public:
55     AttachmentDescription2(const void *pNext, VkAttachmentDescriptionFlags flags, VkFormat format,
56                            VkSampleCountFlagBits samples, VkAttachmentLoadOp loadOp, VkAttachmentStoreOp storeOp,
57                            VkAttachmentLoadOp stencilLoadOp, VkAttachmentStoreOp stencilStoreOp,
58                            VkImageLayout initialLayout, VkImageLayout finalLayout);
59 };
60 
61 class AttachmentReference1 : public vk::VkAttachmentReference
62 {
63 public:
64     AttachmentReference1(const void *pNext, uint32_t attachment, VkImageLayout layout, VkImageAspectFlags aspectMask);
65 };
66 
67 class AttachmentReference2 : public vk::VkAttachmentReference2
68 {
69 public:
70     AttachmentReference2(const void *pNext, uint32_t attachment, VkImageLayout layout, VkImageAspectFlags aspectMask);
71 };
72 
73 class SubpassDescription1 : public vk::VkSubpassDescription
74 {
75 public:
76     SubpassDescription1(const void *pNext, VkSubpassDescriptionFlags flags, VkPipelineBindPoint pipelineBindPoint,
77                         uint32_t viewMask, uint32_t inputAttachmentCount,
78                         const VkAttachmentReference *pInputAttachments, uint32_t colorAttachmentCount,
79                         const VkAttachmentReference *pColorAttachments,
80                         const VkAttachmentReference *pResolveAttachments,
81                         const VkAttachmentReference *pDepthStencilAttachment, uint32_t preserveAttachmentCount,
82                         const uint32_t *pPreserveAttachments);
83 };
84 
85 class SubpassDescription2 : public vk::VkSubpassDescription2
86 {
87 public:
88     SubpassDescription2(const void *pNext, VkSubpassDescriptionFlags flags, VkPipelineBindPoint pipelineBindPoint,
89                         uint32_t viewMask, uint32_t inputAttachmentCount,
90                         const VkAttachmentReference2 *pInputAttachments, uint32_t colorAttachmentCount,
91                         const VkAttachmentReference2 *pColorAttachments,
92                         const VkAttachmentReference2 *pResolveAttachments,
93                         const VkAttachmentReference2 *pDepthStencilAttachment, uint32_t preserveAttachmentCount,
94                         const uint32_t *pPreserveAttachments);
95 };
96 
97 class SubpassDependency1 : public vk::VkSubpassDependency
98 {
99 public:
100     SubpassDependency1(const void *pNext, uint32_t srcSubpass, uint32_t dstSubpass, VkPipelineStageFlags srcStageMask,
101                        VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
102                        VkDependencyFlags dependencyFlags, int32_t viewOffset);
103 };
104 
105 class SubpassDependency2 : public vk::VkSubpassDependency2
106 {
107 public:
108     SubpassDependency2(const void *pNext, uint32_t srcSubpass, uint32_t dstSubpass, VkPipelineStageFlags srcStageMask,
109                        VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
110                        VkDependencyFlags dependencyFlags, int32_t viewOffset);
111 };
112 
113 class RenderPassCreateInfo1 : public VkRenderPassCreateInfo
114 {
115 public:
116     RenderPassCreateInfo1(const void *pNext, VkRenderPassCreateFlags flags, uint32_t attachmentCount,
117                           const VkAttachmentDescription *pAttachments, uint32_t subpassCount,
118                           const VkSubpassDescription *pSubpasses, uint32_t dependencyCount,
119                           const VkSubpassDependency *pDependencies, uint32_t correlatedViewMaskCount,
120                           const uint32_t *pCorrelatedViewMasks);
121 
122     Move<VkRenderPass> createRenderPass(const DeviceInterface &vk, VkDevice device) const;
123 };
124 
125 class RenderPassCreateInfo2 : public VkRenderPassCreateInfo2
126 {
127 public:
128     RenderPassCreateInfo2(const void *pNext, VkRenderPassCreateFlags flags, uint32_t attachmentCount,
129                           const VkAttachmentDescription2 *pAttachments, uint32_t subpassCount,
130                           const VkSubpassDescription2 *pSubpasses, uint32_t dependencyCount,
131                           const VkSubpassDependency2 *pDependencies, uint32_t correlatedViewMaskCount,
132                           const uint32_t *pCorrelatedViewMasks);
133 
134     Move<VkRenderPass> createRenderPass(const DeviceInterface &vk, VkDevice device) const;
135 };
136 
137 class SubpassBeginInfo1
138 {
139 public:
140     SubpassBeginInfo1(const void *pNext, VkSubpassContents contents);
141 
142     VkSubpassContents contents;
143 };
144 
145 class SubpassBeginInfo2 : public VkSubpassBeginInfo
146 {
147 public:
148     SubpassBeginInfo2(const void *pNext, VkSubpassContents contents);
149 };
150 
151 class SubpassEndInfo1
152 {
153 public:
154     SubpassEndInfo1(const void *pNext);
155 };
156 
157 class SubpassEndInfo2 : public VkSubpassEndInfo
158 {
159 public:
160     SubpassEndInfo2(const void *pNext);
161 };
162 
163 class RenderpassSubpass1
164 {
165 public:
166     typedef SubpassBeginInfo1 SubpassBeginInfo;
167     typedef SubpassEndInfo1 SubpassEndInfo;
168 
169     static void cmdBeginRenderPass(const DeviceInterface &vk, VkCommandBuffer cmdBuffer,
170                                    const VkRenderPassBeginInfo *pRenderPassBegin,
171                                    const SubpassBeginInfo *pSubpassBeginInfo);
172 
173     static void cmdNextSubpass(const DeviceInterface &vk, VkCommandBuffer cmdBuffer,
174                                const SubpassBeginInfo *pSubpassBeginInfo, const SubpassEndInfo *pSubpassEndInfo);
175 
176     static void cmdEndRenderPass(const DeviceInterface &vk, VkCommandBuffer cmdBuffer,
177                                  const SubpassEndInfo *pSubpassEndInfo);
178 };
179 
180 class RenderpassSubpass2
181 {
182 public:
183     typedef SubpassBeginInfo2 SubpassBeginInfo;
184     typedef SubpassEndInfo2 SubpassEndInfo;
185 
186     static void cmdBeginRenderPass(const DeviceInterface &vk, VkCommandBuffer cmdBuffer,
187                                    const VkRenderPassBeginInfo *pRenderPassBegin,
188                                    const SubpassBeginInfo *pSubpassBeginInfo);
189 
190     static void cmdNextSubpass(const DeviceInterface &vk, VkCommandBuffer cmdBuffer,
191                                const SubpassBeginInfo *pSubpassBeginInfo, const SubpassEndInfo *pSubpassEndInfo);
192 
193     static void cmdEndRenderPass(const DeviceInterface &vk, VkCommandBuffer cmdBuffer,
194                                  const SubpassEndInfo *pSubpassEndInfo);
195 };
196 
197 // For internal to RP/RP2 conversions
198 
199 class AttachmentReference
200 {
201 public:
202     AttachmentReference(uint32_t attachment, VkImageLayout layout,
203                         VkImageAspectFlags aspectMask = static_cast<VkImageAspectFlags>(0u));
204 
205     uint32_t getAttachment(void) const;
206     VkImageLayout getImageLayout(void) const;
207     VkImageAspectFlags getAspectMask(void) const;
208     void setImageLayout(VkImageLayout layout);
209 
210 private:
211     uint32_t m_attachment;
212     VkImageLayout m_layout;
213     VkImageAspectFlags m_aspectMask;
214 };
215 
216 class Subpass
217 {
218 public:
219     Subpass(VkPipelineBindPoint pipelineBindPoint, VkSubpassDescriptionFlags flags,
220             const std::vector<AttachmentReference> &inputAttachments,
221             const std::vector<AttachmentReference> &colorAttachments,
222             const std::vector<AttachmentReference> &resolveAttachments, AttachmentReference depthStencilAttachment,
223             const std::vector<uint32_t> &preserveAttachments, bool omitBlendState = false);
224 
225     VkPipelineBindPoint getPipelineBindPoint(void) const;
226     VkSubpassDescriptionFlags getFlags(void) const;
227     const std::vector<AttachmentReference> &getInputAttachments(void) const;
228     const std::vector<AttachmentReference> &getColorAttachments(void) const;
229     const std::vector<AttachmentReference> &getResolveAttachments(void) const;
230     const AttachmentReference &getDepthStencilAttachment(void) const;
231     const std::vector<uint32_t> &getPreserveAttachments(void) const;
232     bool getOmitBlendState(void) const;
233 
234 private:
235     VkPipelineBindPoint m_pipelineBindPoint;
236     VkSubpassDescriptionFlags m_flags;
237 
238     std::vector<AttachmentReference> m_inputAttachments;
239     std::vector<AttachmentReference> m_colorAttachments;
240     std::vector<AttachmentReference> m_resolveAttachments;
241     AttachmentReference m_depthStencilAttachment;
242 
243     std::vector<uint32_t> m_preserveAttachments;
244     bool m_omitBlendState;
245 };
246 
247 class SubpassDependency
248 {
249 public:
250     SubpassDependency(uint32_t srcPass, uint32_t dstPass,
251 
252                       VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
253 
254                       VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
255 
256                       VkDependencyFlags flags);
257 
258     uint32_t getSrcPass(void) const;
259     uint32_t getDstPass(void) const;
260 
261     VkPipelineStageFlags getSrcStageMask(void) const;
262     VkPipelineStageFlags getDstStageMask(void) const;
263 
264     VkAccessFlags getSrcAccessMask(void) const;
265     VkAccessFlags getDstAccessMask(void) const;
266 
267     VkDependencyFlags getFlags(void) const;
268 
269 private:
270     uint32_t m_srcPass;
271     uint32_t m_dstPass;
272 
273     VkPipelineStageFlags m_srcStageMask;
274     VkPipelineStageFlags m_dstStageMask;
275 
276     VkAccessFlags m_srcAccessMask;
277     VkAccessFlags m_dstAccessMask;
278     VkDependencyFlags m_flags;
279 };
280 
281 class Attachment
282 {
283 public:
284     Attachment(VkFormat format, VkSampleCountFlagBits samples,
285 
286                VkAttachmentLoadOp loadOp, VkAttachmentStoreOp storeOp,
287 
288                VkAttachmentLoadOp stencilLoadOp, VkAttachmentStoreOp stencilStoreOp,
289 
290                VkImageLayout initialLayout, VkImageLayout finalLayout);
291 
292     VkFormat getFormat(void) const;
293     VkSampleCountFlagBits getSamples(void) const;
294 
295     VkAttachmentLoadOp getLoadOp(void) const;
296     VkAttachmentStoreOp getStoreOp(void) const;
297 
298     VkAttachmentLoadOp getStencilLoadOp(void) const;
299     VkAttachmentStoreOp getStencilStoreOp(void) const;
300 
301     VkImageLayout getInitialLayout(void) const;
302     VkImageLayout getFinalLayout(void) const;
303 
304 private:
305     VkFormat m_format;
306     VkSampleCountFlagBits m_samples;
307 
308     VkAttachmentLoadOp m_loadOp;
309     VkAttachmentStoreOp m_storeOp;
310 
311     VkAttachmentLoadOp m_stencilLoadOp;
312     VkAttachmentStoreOp m_stencilStoreOp;
313 
314     VkImageLayout m_initialLayout;
315     VkImageLayout m_finalLayout;
316 };
317 
318 class RenderPass
319 {
320 public:
321     RenderPass(const std::vector<Attachment> &attachments, const std::vector<Subpass> &subpasses,
322                const std::vector<SubpassDependency> &dependencies,
323                const std::vector<VkInputAttachmentAspectReference> inputAspects =
324                    std::vector<VkInputAttachmentAspectReference>());
325 
326     const std::vector<Attachment> &getAttachments(void) const;
327     const std::vector<Subpass> &getSubpasses(void) const;
328     const std::vector<SubpassDependency> &getDependencies(void) const;
329     const std::vector<VkInputAttachmentAspectReference> &getInputAspects(void) const;
330 
331 private:
332     std::vector<Attachment> m_attachments;
333     std::vector<Subpass> m_subpasses;
334     std::vector<SubpassDependency> m_dependencies;
335     std::vector<VkInputAttachmentAspectReference> m_inputAspects;
336 };
337 
338 Move<VkRenderPass> createRenderPass(const DeviceInterface &vk, VkDevice device, const RenderPass &renderPassInfo,
339                                     RenderingType renderingType,
340                                     SynchronizationType synchronizationType = SYNCHRONIZATION_TYPE_LEGACY);
341 
342 } // namespace renderpass
343 
344 } // namespace vkt
345 
346 #endif // _VKTRENDERPASSTESTSUTIL_HPP
347