1 /* This file is generated by venus-protocol. See vn_protocol_driver.h. */
2
3 /*
4 * Copyright 2020 Google LLC
5 * SPDX-License-Identifier: MIT
6 */
7
8 #ifndef VN_PROTOCOL_DRIVER_RENDER_PASS_H
9 #define VN_PROTOCOL_DRIVER_RENDER_PASS_H
10
11 #include "vn_ring.h"
12 #include "vn_protocol_driver_structs.h"
13
14 /* struct VkAttachmentDescription */
15
16 static inline size_t
vn_sizeof_VkAttachmentDescription(const VkAttachmentDescription * val)17 vn_sizeof_VkAttachmentDescription(const VkAttachmentDescription *val)
18 {
19 size_t size = 0;
20 size += vn_sizeof_VkFlags(&val->flags);
21 size += vn_sizeof_VkFormat(&val->format);
22 size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
23 size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);
24 size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);
25 size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);
26 size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);
27 size += vn_sizeof_VkImageLayout(&val->initialLayout);
28 size += vn_sizeof_VkImageLayout(&val->finalLayout);
29 return size;
30 }
31
32 static inline void
vn_encode_VkAttachmentDescription(struct vn_cs_encoder * enc,const VkAttachmentDescription * val)33 vn_encode_VkAttachmentDescription(struct vn_cs_encoder *enc, const VkAttachmentDescription *val)
34 {
35 vn_encode_VkFlags(enc, &val->flags);
36 vn_encode_VkFormat(enc, &val->format);
37 vn_encode_VkSampleCountFlagBits(enc, &val->samples);
38 vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);
39 vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);
40 vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);
41 vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);
42 vn_encode_VkImageLayout(enc, &val->initialLayout);
43 vn_encode_VkImageLayout(enc, &val->finalLayout);
44 }
45
46 /* struct VkAttachmentReference */
47
48 static inline size_t
vn_sizeof_VkAttachmentReference(const VkAttachmentReference * val)49 vn_sizeof_VkAttachmentReference(const VkAttachmentReference *val)
50 {
51 size_t size = 0;
52 size += vn_sizeof_uint32_t(&val->attachment);
53 size += vn_sizeof_VkImageLayout(&val->layout);
54 return size;
55 }
56
57 static inline void
vn_encode_VkAttachmentReference(struct vn_cs_encoder * enc,const VkAttachmentReference * val)58 vn_encode_VkAttachmentReference(struct vn_cs_encoder *enc, const VkAttachmentReference *val)
59 {
60 vn_encode_uint32_t(enc, &val->attachment);
61 vn_encode_VkImageLayout(enc, &val->layout);
62 }
63
64 /* struct VkSubpassDescription */
65
66 static inline size_t
vn_sizeof_VkSubpassDescription(const VkSubpassDescription * val)67 vn_sizeof_VkSubpassDescription(const VkSubpassDescription *val)
68 {
69 size_t size = 0;
70 size += vn_sizeof_VkFlags(&val->flags);
71 size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
72 size += vn_sizeof_uint32_t(&val->inputAttachmentCount);
73 if (val->pInputAttachments) {
74 size += vn_sizeof_array_size(val->inputAttachmentCount);
75 for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
76 size += vn_sizeof_VkAttachmentReference(&val->pInputAttachments[i]);
77 } else {
78 size += vn_sizeof_array_size(0);
79 }
80 size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
81 if (val->pColorAttachments) {
82 size += vn_sizeof_array_size(val->colorAttachmentCount);
83 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
84 size += vn_sizeof_VkAttachmentReference(&val->pColorAttachments[i]);
85 } else {
86 size += vn_sizeof_array_size(0);
87 }
88 if (val->pResolveAttachments) {
89 size += vn_sizeof_array_size(val->colorAttachmentCount);
90 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
91 size += vn_sizeof_VkAttachmentReference(&val->pResolveAttachments[i]);
92 } else {
93 size += vn_sizeof_array_size(0);
94 }
95 size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);
96 if (val->pDepthStencilAttachment)
97 size += vn_sizeof_VkAttachmentReference(val->pDepthStencilAttachment);
98 size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);
99 if (val->pPreserveAttachments) {
100 size += vn_sizeof_array_size(val->preserveAttachmentCount);
101 size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);
102 } else {
103 size += vn_sizeof_array_size(0);
104 }
105 return size;
106 }
107
108 static inline void
vn_encode_VkSubpassDescription(struct vn_cs_encoder * enc,const VkSubpassDescription * val)109 vn_encode_VkSubpassDescription(struct vn_cs_encoder *enc, const VkSubpassDescription *val)
110 {
111 vn_encode_VkFlags(enc, &val->flags);
112 vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
113 vn_encode_uint32_t(enc, &val->inputAttachmentCount);
114 if (val->pInputAttachments) {
115 vn_encode_array_size(enc, val->inputAttachmentCount);
116 for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
117 vn_encode_VkAttachmentReference(enc, &val->pInputAttachments[i]);
118 } else {
119 vn_encode_array_size(enc, 0);
120 }
121 vn_encode_uint32_t(enc, &val->colorAttachmentCount);
122 if (val->pColorAttachments) {
123 vn_encode_array_size(enc, val->colorAttachmentCount);
124 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
125 vn_encode_VkAttachmentReference(enc, &val->pColorAttachments[i]);
126 } else {
127 vn_encode_array_size(enc, 0);
128 }
129 if (val->pResolveAttachments) {
130 vn_encode_array_size(enc, val->colorAttachmentCount);
131 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
132 vn_encode_VkAttachmentReference(enc, &val->pResolveAttachments[i]);
133 } else {
134 vn_encode_array_size(enc, 0);
135 }
136 if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))
137 vn_encode_VkAttachmentReference(enc, val->pDepthStencilAttachment);
138 vn_encode_uint32_t(enc, &val->preserveAttachmentCount);
139 if (val->pPreserveAttachments) {
140 vn_encode_array_size(enc, val->preserveAttachmentCount);
141 vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);
142 } else {
143 vn_encode_array_size(enc, 0);
144 }
145 }
146
147 /* struct VkSubpassDependency */
148
149 static inline size_t
vn_sizeof_VkSubpassDependency(const VkSubpassDependency * val)150 vn_sizeof_VkSubpassDependency(const VkSubpassDependency *val)
151 {
152 size_t size = 0;
153 size += vn_sizeof_uint32_t(&val->srcSubpass);
154 size += vn_sizeof_uint32_t(&val->dstSubpass);
155 size += vn_sizeof_VkFlags(&val->srcStageMask);
156 size += vn_sizeof_VkFlags(&val->dstStageMask);
157 size += vn_sizeof_VkFlags(&val->srcAccessMask);
158 size += vn_sizeof_VkFlags(&val->dstAccessMask);
159 size += vn_sizeof_VkFlags(&val->dependencyFlags);
160 return size;
161 }
162
163 static inline void
vn_encode_VkSubpassDependency(struct vn_cs_encoder * enc,const VkSubpassDependency * val)164 vn_encode_VkSubpassDependency(struct vn_cs_encoder *enc, const VkSubpassDependency *val)
165 {
166 vn_encode_uint32_t(enc, &val->srcSubpass);
167 vn_encode_uint32_t(enc, &val->dstSubpass);
168 vn_encode_VkFlags(enc, &val->srcStageMask);
169 vn_encode_VkFlags(enc, &val->dstStageMask);
170 vn_encode_VkFlags(enc, &val->srcAccessMask);
171 vn_encode_VkFlags(enc, &val->dstAccessMask);
172 vn_encode_VkFlags(enc, &val->dependencyFlags);
173 }
174
175 /* struct VkRenderPassMultiviewCreateInfo chain */
176
177 static inline size_t
vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(const void * val)178 vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(const void *val)
179 {
180 /* no known/supported struct */
181 return vn_sizeof_simple_pointer(NULL);
182 }
183
184 static inline size_t
vn_sizeof_VkRenderPassMultiviewCreateInfo_self(const VkRenderPassMultiviewCreateInfo * val)185 vn_sizeof_VkRenderPassMultiviewCreateInfo_self(const VkRenderPassMultiviewCreateInfo *val)
186 {
187 size_t size = 0;
188 /* skip val->{sType,pNext} */
189 size += vn_sizeof_uint32_t(&val->subpassCount);
190 if (val->pViewMasks) {
191 size += vn_sizeof_array_size(val->subpassCount);
192 size += vn_sizeof_uint32_t_array(val->pViewMasks, val->subpassCount);
193 } else {
194 size += vn_sizeof_array_size(0);
195 }
196 size += vn_sizeof_uint32_t(&val->dependencyCount);
197 if (val->pViewOffsets) {
198 size += vn_sizeof_array_size(val->dependencyCount);
199 size += vn_sizeof_int32_t_array(val->pViewOffsets, val->dependencyCount);
200 } else {
201 size += vn_sizeof_array_size(0);
202 }
203 size += vn_sizeof_uint32_t(&val->correlationMaskCount);
204 if (val->pCorrelationMasks) {
205 size += vn_sizeof_array_size(val->correlationMaskCount);
206 size += vn_sizeof_uint32_t_array(val->pCorrelationMasks, val->correlationMaskCount);
207 } else {
208 size += vn_sizeof_array_size(0);
209 }
210 return size;
211 }
212
213 static inline size_t
vn_sizeof_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo * val)214 vn_sizeof_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo *val)
215 {
216 size_t size = 0;
217
218 size += vn_sizeof_VkStructureType(&val->sType);
219 size += vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(val->pNext);
220 size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self(val);
221
222 return size;
223 }
224
225 static inline void
vn_encode_VkRenderPassMultiviewCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)226 vn_encode_VkRenderPassMultiviewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
227 {
228 /* no known/supported struct */
229 vn_encode_simple_pointer(enc, NULL);
230 }
231
232 static inline void
vn_encode_VkRenderPassMultiviewCreateInfo_self(struct vn_cs_encoder * enc,const VkRenderPassMultiviewCreateInfo * val)233 vn_encode_VkRenderPassMultiviewCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)
234 {
235 /* skip val->{sType,pNext} */
236 vn_encode_uint32_t(enc, &val->subpassCount);
237 if (val->pViewMasks) {
238 vn_encode_array_size(enc, val->subpassCount);
239 vn_encode_uint32_t_array(enc, val->pViewMasks, val->subpassCount);
240 } else {
241 vn_encode_array_size(enc, 0);
242 }
243 vn_encode_uint32_t(enc, &val->dependencyCount);
244 if (val->pViewOffsets) {
245 vn_encode_array_size(enc, val->dependencyCount);
246 vn_encode_int32_t_array(enc, val->pViewOffsets, val->dependencyCount);
247 } else {
248 vn_encode_array_size(enc, 0);
249 }
250 vn_encode_uint32_t(enc, &val->correlationMaskCount);
251 if (val->pCorrelationMasks) {
252 vn_encode_array_size(enc, val->correlationMaskCount);
253 vn_encode_uint32_t_array(enc, val->pCorrelationMasks, val->correlationMaskCount);
254 } else {
255 vn_encode_array_size(enc, 0);
256 }
257 }
258
259 static inline void
vn_encode_VkRenderPassMultiviewCreateInfo(struct vn_cs_encoder * enc,const VkRenderPassMultiviewCreateInfo * val)260 vn_encode_VkRenderPassMultiviewCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassMultiviewCreateInfo *val)
261 {
262 assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO);
263 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO });
264 vn_encode_VkRenderPassMultiviewCreateInfo_pnext(enc, val->pNext);
265 vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, val);
266 }
267
268 /* struct VkInputAttachmentAspectReference */
269
270 static inline size_t
vn_sizeof_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference * val)271 vn_sizeof_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference *val)
272 {
273 size_t size = 0;
274 size += vn_sizeof_uint32_t(&val->subpass);
275 size += vn_sizeof_uint32_t(&val->inputAttachmentIndex);
276 size += vn_sizeof_VkFlags(&val->aspectMask);
277 return size;
278 }
279
280 static inline void
vn_encode_VkInputAttachmentAspectReference(struct vn_cs_encoder * enc,const VkInputAttachmentAspectReference * val)281 vn_encode_VkInputAttachmentAspectReference(struct vn_cs_encoder *enc, const VkInputAttachmentAspectReference *val)
282 {
283 vn_encode_uint32_t(enc, &val->subpass);
284 vn_encode_uint32_t(enc, &val->inputAttachmentIndex);
285 vn_encode_VkFlags(enc, &val->aspectMask);
286 }
287
288 /* struct VkRenderPassInputAttachmentAspectCreateInfo chain */
289
290 static inline size_t
vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(const void * val)291 vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(const void *val)
292 {
293 /* no known/supported struct */
294 return vn_sizeof_simple_pointer(NULL);
295 }
296
297 static inline size_t
vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(const VkRenderPassInputAttachmentAspectCreateInfo * val)298 vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(const VkRenderPassInputAttachmentAspectCreateInfo *val)
299 {
300 size_t size = 0;
301 /* skip val->{sType,pNext} */
302 size += vn_sizeof_uint32_t(&val->aspectReferenceCount);
303 if (val->pAspectReferences) {
304 size += vn_sizeof_array_size(val->aspectReferenceCount);
305 for (uint32_t i = 0; i < val->aspectReferenceCount; i++)
306 size += vn_sizeof_VkInputAttachmentAspectReference(&val->pAspectReferences[i]);
307 } else {
308 size += vn_sizeof_array_size(0);
309 }
310 return size;
311 }
312
313 static inline size_t
vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo * val)314 vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo *val)
315 {
316 size_t size = 0;
317
318 size += vn_sizeof_VkStructureType(&val->sType);
319 size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(val->pNext);
320 size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self(val);
321
322 return size;
323 }
324
325 static inline void
vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)326 vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
327 {
328 /* no known/supported struct */
329 vn_encode_simple_pointer(enc, NULL);
330 }
331
332 static inline void
vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(struct vn_cs_encoder * enc,const VkRenderPassInputAttachmentAspectCreateInfo * val)333 vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)
334 {
335 /* skip val->{sType,pNext} */
336 vn_encode_uint32_t(enc, &val->aspectReferenceCount);
337 if (val->pAspectReferences) {
338 vn_encode_array_size(enc, val->aspectReferenceCount);
339 for (uint32_t i = 0; i < val->aspectReferenceCount; i++)
340 vn_encode_VkInputAttachmentAspectReference(enc, &val->pAspectReferences[i]);
341 } else {
342 vn_encode_array_size(enc, 0);
343 }
344 }
345
346 static inline void
vn_encode_VkRenderPassInputAttachmentAspectCreateInfo(struct vn_cs_encoder * enc,const VkRenderPassInputAttachmentAspectCreateInfo * val)347 vn_encode_VkRenderPassInputAttachmentAspectCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassInputAttachmentAspectCreateInfo *val)
348 {
349 assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO);
350 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO });
351 vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_pnext(enc, val->pNext);
352 vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, val);
353 }
354
355 /* struct VkRenderPassCreateInfo chain */
356
357 static inline size_t
vn_sizeof_VkRenderPassCreateInfo_pnext(const void * val)358 vn_sizeof_VkRenderPassCreateInfo_pnext(const void *val)
359 {
360 const VkBaseInStructure *pnext = val;
361 size_t size = 0;
362
363 while (pnext) {
364 switch ((int32_t)pnext->sType) {
365 case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
366 size += vn_sizeof_simple_pointer(pnext);
367 size += vn_sizeof_VkStructureType(&pnext->sType);
368 size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);
369 size += vn_sizeof_VkRenderPassMultiviewCreateInfo_self((const VkRenderPassMultiviewCreateInfo *)pnext);
370 return size;
371 case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
372 size += vn_sizeof_simple_pointer(pnext);
373 size += vn_sizeof_VkStructureType(&pnext->sType);
374 size += vn_sizeof_VkRenderPassCreateInfo_pnext(pnext->pNext);
375 size += vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_self((const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);
376 return size;
377 default:
378 /* ignore unknown/unsupported struct */
379 break;
380 }
381 pnext = pnext->pNext;
382 }
383
384 return vn_sizeof_simple_pointer(NULL);
385 }
386
387 static inline size_t
vn_sizeof_VkRenderPassCreateInfo_self(const VkRenderPassCreateInfo * val)388 vn_sizeof_VkRenderPassCreateInfo_self(const VkRenderPassCreateInfo *val)
389 {
390 size_t size = 0;
391 /* skip val->{sType,pNext} */
392 size += vn_sizeof_VkFlags(&val->flags);
393 size += vn_sizeof_uint32_t(&val->attachmentCount);
394 if (val->pAttachments) {
395 size += vn_sizeof_array_size(val->attachmentCount);
396 for (uint32_t i = 0; i < val->attachmentCount; i++)
397 size += vn_sizeof_VkAttachmentDescription(&val->pAttachments[i]);
398 } else {
399 size += vn_sizeof_array_size(0);
400 }
401 size += vn_sizeof_uint32_t(&val->subpassCount);
402 if (val->pSubpasses) {
403 size += vn_sizeof_array_size(val->subpassCount);
404 for (uint32_t i = 0; i < val->subpassCount; i++)
405 size += vn_sizeof_VkSubpassDescription(&val->pSubpasses[i]);
406 } else {
407 size += vn_sizeof_array_size(0);
408 }
409 size += vn_sizeof_uint32_t(&val->dependencyCount);
410 if (val->pDependencies) {
411 size += vn_sizeof_array_size(val->dependencyCount);
412 for (uint32_t i = 0; i < val->dependencyCount; i++)
413 size += vn_sizeof_VkSubpassDependency(&val->pDependencies[i]);
414 } else {
415 size += vn_sizeof_array_size(0);
416 }
417 return size;
418 }
419
420 static inline size_t
vn_sizeof_VkRenderPassCreateInfo(const VkRenderPassCreateInfo * val)421 vn_sizeof_VkRenderPassCreateInfo(const VkRenderPassCreateInfo *val)
422 {
423 size_t size = 0;
424
425 size += vn_sizeof_VkStructureType(&val->sType);
426 size += vn_sizeof_VkRenderPassCreateInfo_pnext(val->pNext);
427 size += vn_sizeof_VkRenderPassCreateInfo_self(val);
428
429 return size;
430 }
431
432 static inline void
vn_encode_VkRenderPassCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)433 vn_encode_VkRenderPassCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
434 {
435 const VkBaseInStructure *pnext = val;
436
437 while (pnext) {
438 switch ((int32_t)pnext->sType) {
439 case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
440 vn_encode_simple_pointer(enc, pnext);
441 vn_encode_VkStructureType(enc, &pnext->sType);
442 vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);
443 vn_encode_VkRenderPassMultiviewCreateInfo_self(enc, (const VkRenderPassMultiviewCreateInfo *)pnext);
444 return;
445 case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
446 vn_encode_simple_pointer(enc, pnext);
447 vn_encode_VkStructureType(enc, &pnext->sType);
448 vn_encode_VkRenderPassCreateInfo_pnext(enc, pnext->pNext);
449 vn_encode_VkRenderPassInputAttachmentAspectCreateInfo_self(enc, (const VkRenderPassInputAttachmentAspectCreateInfo *)pnext);
450 return;
451 default:
452 /* ignore unknown/unsupported struct */
453 break;
454 }
455 pnext = pnext->pNext;
456 }
457
458 vn_encode_simple_pointer(enc, NULL);
459 }
460
461 static inline void
vn_encode_VkRenderPassCreateInfo_self(struct vn_cs_encoder * enc,const VkRenderPassCreateInfo * val)462 vn_encode_VkRenderPassCreateInfo_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)
463 {
464 /* skip val->{sType,pNext} */
465 vn_encode_VkFlags(enc, &val->flags);
466 vn_encode_uint32_t(enc, &val->attachmentCount);
467 if (val->pAttachments) {
468 vn_encode_array_size(enc, val->attachmentCount);
469 for (uint32_t i = 0; i < val->attachmentCount; i++)
470 vn_encode_VkAttachmentDescription(enc, &val->pAttachments[i]);
471 } else {
472 vn_encode_array_size(enc, 0);
473 }
474 vn_encode_uint32_t(enc, &val->subpassCount);
475 if (val->pSubpasses) {
476 vn_encode_array_size(enc, val->subpassCount);
477 for (uint32_t i = 0; i < val->subpassCount; i++)
478 vn_encode_VkSubpassDescription(enc, &val->pSubpasses[i]);
479 } else {
480 vn_encode_array_size(enc, 0);
481 }
482 vn_encode_uint32_t(enc, &val->dependencyCount);
483 if (val->pDependencies) {
484 vn_encode_array_size(enc, val->dependencyCount);
485 for (uint32_t i = 0; i < val->dependencyCount; i++)
486 vn_encode_VkSubpassDependency(enc, &val->pDependencies[i]);
487 } else {
488 vn_encode_array_size(enc, 0);
489 }
490 }
491
492 static inline void
vn_encode_VkRenderPassCreateInfo(struct vn_cs_encoder * enc,const VkRenderPassCreateInfo * val)493 vn_encode_VkRenderPassCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo *val)
494 {
495 assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
496 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO });
497 vn_encode_VkRenderPassCreateInfo_pnext(enc, val->pNext);
498 vn_encode_VkRenderPassCreateInfo_self(enc, val);
499 }
500
501 /* struct VkRenderingAreaInfoKHR chain */
502
503 static inline size_t
vn_sizeof_VkRenderingAreaInfoKHR_pnext(const void * val)504 vn_sizeof_VkRenderingAreaInfoKHR_pnext(const void *val)
505 {
506 /* no known/supported struct */
507 return vn_sizeof_simple_pointer(NULL);
508 }
509
510 static inline size_t
vn_sizeof_VkRenderingAreaInfoKHR_self(const VkRenderingAreaInfoKHR * val)511 vn_sizeof_VkRenderingAreaInfoKHR_self(const VkRenderingAreaInfoKHR *val)
512 {
513 size_t size = 0;
514 /* skip val->{sType,pNext} */
515 size += vn_sizeof_uint32_t(&val->viewMask);
516 size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
517 if (val->pColorAttachmentFormats) {
518 size += vn_sizeof_array_size(val->colorAttachmentCount);
519 size += vn_sizeof_VkFormat_array(val->pColorAttachmentFormats, val->colorAttachmentCount);
520 } else {
521 size += vn_sizeof_array_size(0);
522 }
523 size += vn_sizeof_VkFormat(&val->depthAttachmentFormat);
524 size += vn_sizeof_VkFormat(&val->stencilAttachmentFormat);
525 return size;
526 }
527
528 static inline size_t
vn_sizeof_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR * val)529 vn_sizeof_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR *val)
530 {
531 size_t size = 0;
532
533 size += vn_sizeof_VkStructureType(&val->sType);
534 size += vn_sizeof_VkRenderingAreaInfoKHR_pnext(val->pNext);
535 size += vn_sizeof_VkRenderingAreaInfoKHR_self(val);
536
537 return size;
538 }
539
540 static inline void
vn_encode_VkRenderingAreaInfoKHR_pnext(struct vn_cs_encoder * enc,const void * val)541 vn_encode_VkRenderingAreaInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
542 {
543 /* no known/supported struct */
544 vn_encode_simple_pointer(enc, NULL);
545 }
546
547 static inline void
vn_encode_VkRenderingAreaInfoKHR_self(struct vn_cs_encoder * enc,const VkRenderingAreaInfoKHR * val)548 vn_encode_VkRenderingAreaInfoKHR_self(struct vn_cs_encoder *enc, const VkRenderingAreaInfoKHR *val)
549 {
550 /* skip val->{sType,pNext} */
551 vn_encode_uint32_t(enc, &val->viewMask);
552 vn_encode_uint32_t(enc, &val->colorAttachmentCount);
553 if (val->pColorAttachmentFormats) {
554 vn_encode_array_size(enc, val->colorAttachmentCount);
555 vn_encode_VkFormat_array(enc, val->pColorAttachmentFormats, val->colorAttachmentCount);
556 } else {
557 vn_encode_array_size(enc, 0);
558 }
559 vn_encode_VkFormat(enc, &val->depthAttachmentFormat);
560 vn_encode_VkFormat(enc, &val->stencilAttachmentFormat);
561 }
562
563 static inline void
vn_encode_VkRenderingAreaInfoKHR(struct vn_cs_encoder * enc,const VkRenderingAreaInfoKHR * val)564 vn_encode_VkRenderingAreaInfoKHR(struct vn_cs_encoder *enc, const VkRenderingAreaInfoKHR *val)
565 {
566 assert(val->sType == VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR);
567 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR });
568 vn_encode_VkRenderingAreaInfoKHR_pnext(enc, val->pNext);
569 vn_encode_VkRenderingAreaInfoKHR_self(enc, val);
570 }
571
572 /* struct VkAttachmentDescriptionStencilLayout chain */
573
574 static inline size_t
vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(const void * val)575 vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(const void *val)
576 {
577 /* no known/supported struct */
578 return vn_sizeof_simple_pointer(NULL);
579 }
580
581 static inline size_t
vn_sizeof_VkAttachmentDescriptionStencilLayout_self(const VkAttachmentDescriptionStencilLayout * val)582 vn_sizeof_VkAttachmentDescriptionStencilLayout_self(const VkAttachmentDescriptionStencilLayout *val)
583 {
584 size_t size = 0;
585 /* skip val->{sType,pNext} */
586 size += vn_sizeof_VkImageLayout(&val->stencilInitialLayout);
587 size += vn_sizeof_VkImageLayout(&val->stencilFinalLayout);
588 return size;
589 }
590
591 static inline size_t
vn_sizeof_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout * val)592 vn_sizeof_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout *val)
593 {
594 size_t size = 0;
595
596 size += vn_sizeof_VkStructureType(&val->sType);
597 size += vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(val->pNext);
598 size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self(val);
599
600 return size;
601 }
602
603 static inline void
vn_encode_VkAttachmentDescriptionStencilLayout_pnext(struct vn_cs_encoder * enc,const void * val)604 vn_encode_VkAttachmentDescriptionStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
605 {
606 /* no known/supported struct */
607 vn_encode_simple_pointer(enc, NULL);
608 }
609
610 static inline void
vn_encode_VkAttachmentDescriptionStencilLayout_self(struct vn_cs_encoder * enc,const VkAttachmentDescriptionStencilLayout * val)611 vn_encode_VkAttachmentDescriptionStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
612 {
613 /* skip val->{sType,pNext} */
614 vn_encode_VkImageLayout(enc, &val->stencilInitialLayout);
615 vn_encode_VkImageLayout(enc, &val->stencilFinalLayout);
616 }
617
618 static inline void
vn_encode_VkAttachmentDescriptionStencilLayout(struct vn_cs_encoder * enc,const VkAttachmentDescriptionStencilLayout * val)619 vn_encode_VkAttachmentDescriptionStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
620 {
621 assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);
622 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT });
623 vn_encode_VkAttachmentDescriptionStencilLayout_pnext(enc, val->pNext);
624 vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, val);
625 }
626
627 /* struct VkAttachmentDescription2 chain */
628
629 static inline size_t
vn_sizeof_VkAttachmentDescription2_pnext(const void * val)630 vn_sizeof_VkAttachmentDescription2_pnext(const void *val)
631 {
632 const VkBaseInStructure *pnext = val;
633 size_t size = 0;
634
635 while (pnext) {
636 switch ((int32_t)pnext->sType) {
637 case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
638 size += vn_sizeof_simple_pointer(pnext);
639 size += vn_sizeof_VkStructureType(&pnext->sType);
640 size += vn_sizeof_VkAttachmentDescription2_pnext(pnext->pNext);
641 size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self((const VkAttachmentDescriptionStencilLayout *)pnext);
642 return size;
643 default:
644 /* ignore unknown/unsupported struct */
645 break;
646 }
647 pnext = pnext->pNext;
648 }
649
650 return vn_sizeof_simple_pointer(NULL);
651 }
652
653 static inline size_t
vn_sizeof_VkAttachmentDescription2_self(const VkAttachmentDescription2 * val)654 vn_sizeof_VkAttachmentDescription2_self(const VkAttachmentDescription2 *val)
655 {
656 size_t size = 0;
657 /* skip val->{sType,pNext} */
658 size += vn_sizeof_VkFlags(&val->flags);
659 size += vn_sizeof_VkFormat(&val->format);
660 size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
661 size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);
662 size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);
663 size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);
664 size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);
665 size += vn_sizeof_VkImageLayout(&val->initialLayout);
666 size += vn_sizeof_VkImageLayout(&val->finalLayout);
667 return size;
668 }
669
670 static inline size_t
vn_sizeof_VkAttachmentDescription2(const VkAttachmentDescription2 * val)671 vn_sizeof_VkAttachmentDescription2(const VkAttachmentDescription2 *val)
672 {
673 size_t size = 0;
674
675 size += vn_sizeof_VkStructureType(&val->sType);
676 size += vn_sizeof_VkAttachmentDescription2_pnext(val->pNext);
677 size += vn_sizeof_VkAttachmentDescription2_self(val);
678
679 return size;
680 }
681
682 static inline void
vn_encode_VkAttachmentDescription2_pnext(struct vn_cs_encoder * enc,const void * val)683 vn_encode_VkAttachmentDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
684 {
685 const VkBaseInStructure *pnext = val;
686
687 while (pnext) {
688 switch ((int32_t)pnext->sType) {
689 case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
690 vn_encode_simple_pointer(enc, pnext);
691 vn_encode_VkStructureType(enc, &pnext->sType);
692 vn_encode_VkAttachmentDescription2_pnext(enc, pnext->pNext);
693 vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, (const VkAttachmentDescriptionStencilLayout *)pnext);
694 return;
695 default:
696 /* ignore unknown/unsupported struct */
697 break;
698 }
699 pnext = pnext->pNext;
700 }
701
702 vn_encode_simple_pointer(enc, NULL);
703 }
704
705 static inline void
vn_encode_VkAttachmentDescription2_self(struct vn_cs_encoder * enc,const VkAttachmentDescription2 * val)706 vn_encode_VkAttachmentDescription2_self(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
707 {
708 /* skip val->{sType,pNext} */
709 vn_encode_VkFlags(enc, &val->flags);
710 vn_encode_VkFormat(enc, &val->format);
711 vn_encode_VkSampleCountFlagBits(enc, &val->samples);
712 vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);
713 vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);
714 vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);
715 vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);
716 vn_encode_VkImageLayout(enc, &val->initialLayout);
717 vn_encode_VkImageLayout(enc, &val->finalLayout);
718 }
719
720 static inline void
vn_encode_VkAttachmentDescription2(struct vn_cs_encoder * enc,const VkAttachmentDescription2 * val)721 vn_encode_VkAttachmentDescription2(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
722 {
723 assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2);
724 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 });
725 vn_encode_VkAttachmentDescription2_pnext(enc, val->pNext);
726 vn_encode_VkAttachmentDescription2_self(enc, val);
727 }
728
729 /* struct VkAttachmentReferenceStencilLayout chain */
730
731 static inline size_t
vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(const void * val)732 vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(const void *val)
733 {
734 /* no known/supported struct */
735 return vn_sizeof_simple_pointer(NULL);
736 }
737
738 static inline size_t
vn_sizeof_VkAttachmentReferenceStencilLayout_self(const VkAttachmentReferenceStencilLayout * val)739 vn_sizeof_VkAttachmentReferenceStencilLayout_self(const VkAttachmentReferenceStencilLayout *val)
740 {
741 size_t size = 0;
742 /* skip val->{sType,pNext} */
743 size += vn_sizeof_VkImageLayout(&val->stencilLayout);
744 return size;
745 }
746
747 static inline size_t
vn_sizeof_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout * val)748 vn_sizeof_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout *val)
749 {
750 size_t size = 0;
751
752 size += vn_sizeof_VkStructureType(&val->sType);
753 size += vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(val->pNext);
754 size += vn_sizeof_VkAttachmentReferenceStencilLayout_self(val);
755
756 return size;
757 }
758
759 static inline void
vn_encode_VkAttachmentReferenceStencilLayout_pnext(struct vn_cs_encoder * enc,const void * val)760 vn_encode_VkAttachmentReferenceStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
761 {
762 /* no known/supported struct */
763 vn_encode_simple_pointer(enc, NULL);
764 }
765
766 static inline void
vn_encode_VkAttachmentReferenceStencilLayout_self(struct vn_cs_encoder * enc,const VkAttachmentReferenceStencilLayout * val)767 vn_encode_VkAttachmentReferenceStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
768 {
769 /* skip val->{sType,pNext} */
770 vn_encode_VkImageLayout(enc, &val->stencilLayout);
771 }
772
773 static inline void
vn_encode_VkAttachmentReferenceStencilLayout(struct vn_cs_encoder * enc,const VkAttachmentReferenceStencilLayout * val)774 vn_encode_VkAttachmentReferenceStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
775 {
776 assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT);
777 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT });
778 vn_encode_VkAttachmentReferenceStencilLayout_pnext(enc, val->pNext);
779 vn_encode_VkAttachmentReferenceStencilLayout_self(enc, val);
780 }
781
782 /* struct VkAttachmentReference2 chain */
783
784 static inline size_t
vn_sizeof_VkAttachmentReference2_pnext(const void * val)785 vn_sizeof_VkAttachmentReference2_pnext(const void *val)
786 {
787 const VkBaseInStructure *pnext = val;
788 size_t size = 0;
789
790 while (pnext) {
791 switch ((int32_t)pnext->sType) {
792 case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
793 size += vn_sizeof_simple_pointer(pnext);
794 size += vn_sizeof_VkStructureType(&pnext->sType);
795 size += vn_sizeof_VkAttachmentReference2_pnext(pnext->pNext);
796 size += vn_sizeof_VkAttachmentReferenceStencilLayout_self((const VkAttachmentReferenceStencilLayout *)pnext);
797 return size;
798 default:
799 /* ignore unknown/unsupported struct */
800 break;
801 }
802 pnext = pnext->pNext;
803 }
804
805 return vn_sizeof_simple_pointer(NULL);
806 }
807
808 static inline size_t
vn_sizeof_VkAttachmentReference2_self(const VkAttachmentReference2 * val)809 vn_sizeof_VkAttachmentReference2_self(const VkAttachmentReference2 *val)
810 {
811 size_t size = 0;
812 /* skip val->{sType,pNext} */
813 size += vn_sizeof_uint32_t(&val->attachment);
814 size += vn_sizeof_VkImageLayout(&val->layout);
815 size += vn_sizeof_VkFlags(&val->aspectMask);
816 return size;
817 }
818
819 static inline size_t
vn_sizeof_VkAttachmentReference2(const VkAttachmentReference2 * val)820 vn_sizeof_VkAttachmentReference2(const VkAttachmentReference2 *val)
821 {
822 size_t size = 0;
823
824 size += vn_sizeof_VkStructureType(&val->sType);
825 size += vn_sizeof_VkAttachmentReference2_pnext(val->pNext);
826 size += vn_sizeof_VkAttachmentReference2_self(val);
827
828 return size;
829 }
830
831 static inline void
vn_encode_VkAttachmentReference2_pnext(struct vn_cs_encoder * enc,const void * val)832 vn_encode_VkAttachmentReference2_pnext(struct vn_cs_encoder *enc, const void *val)
833 {
834 const VkBaseInStructure *pnext = val;
835
836 while (pnext) {
837 switch ((int32_t)pnext->sType) {
838 case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
839 vn_encode_simple_pointer(enc, pnext);
840 vn_encode_VkStructureType(enc, &pnext->sType);
841 vn_encode_VkAttachmentReference2_pnext(enc, pnext->pNext);
842 vn_encode_VkAttachmentReferenceStencilLayout_self(enc, (const VkAttachmentReferenceStencilLayout *)pnext);
843 return;
844 default:
845 /* ignore unknown/unsupported struct */
846 break;
847 }
848 pnext = pnext->pNext;
849 }
850
851 vn_encode_simple_pointer(enc, NULL);
852 }
853
854 static inline void
vn_encode_VkAttachmentReference2_self(struct vn_cs_encoder * enc,const VkAttachmentReference2 * val)855 vn_encode_VkAttachmentReference2_self(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
856 {
857 /* skip val->{sType,pNext} */
858 vn_encode_uint32_t(enc, &val->attachment);
859 vn_encode_VkImageLayout(enc, &val->layout);
860 vn_encode_VkFlags(enc, &val->aspectMask);
861 }
862
863 static inline void
vn_encode_VkAttachmentReference2(struct vn_cs_encoder * enc,const VkAttachmentReference2 * val)864 vn_encode_VkAttachmentReference2(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
865 {
866 assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2);
867 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 });
868 vn_encode_VkAttachmentReference2_pnext(enc, val->pNext);
869 vn_encode_VkAttachmentReference2_self(enc, val);
870 }
871
872 /* struct VkSubpassDescriptionDepthStencilResolve chain */
873
874 static inline size_t
vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(const void * val)875 vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(const void *val)
876 {
877 /* no known/supported struct */
878 return vn_sizeof_simple_pointer(NULL);
879 }
880
881 static inline size_t
vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(const VkSubpassDescriptionDepthStencilResolve * val)882 vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(const VkSubpassDescriptionDepthStencilResolve *val)
883 {
884 size_t size = 0;
885 /* skip val->{sType,pNext} */
886 size += vn_sizeof_VkResolveModeFlagBits(&val->depthResolveMode);
887 size += vn_sizeof_VkResolveModeFlagBits(&val->stencilResolveMode);
888 size += vn_sizeof_simple_pointer(val->pDepthStencilResolveAttachment);
889 if (val->pDepthStencilResolveAttachment)
890 size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilResolveAttachment);
891 return size;
892 }
893
894 static inline size_t
vn_sizeof_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve * val)895 vn_sizeof_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve *val)
896 {
897 size_t size = 0;
898
899 size += vn_sizeof_VkStructureType(&val->sType);
900 size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(val->pNext);
901 size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(val);
902
903 return size;
904 }
905
906 static inline void
vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(struct vn_cs_encoder * enc,const void * val)907 vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(struct vn_cs_encoder *enc, const void *val)
908 {
909 /* no known/supported struct */
910 vn_encode_simple_pointer(enc, NULL);
911 }
912
913 static inline void
vn_encode_VkSubpassDescriptionDepthStencilResolve_self(struct vn_cs_encoder * enc,const VkSubpassDescriptionDepthStencilResolve * val)914 vn_encode_VkSubpassDescriptionDepthStencilResolve_self(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
915 {
916 /* skip val->{sType,pNext} */
917 vn_encode_VkResolveModeFlagBits(enc, &val->depthResolveMode);
918 vn_encode_VkResolveModeFlagBits(enc, &val->stencilResolveMode);
919 if (vn_encode_simple_pointer(enc, val->pDepthStencilResolveAttachment))
920 vn_encode_VkAttachmentReference2(enc, val->pDepthStencilResolveAttachment);
921 }
922
923 static inline void
vn_encode_VkSubpassDescriptionDepthStencilResolve(struct vn_cs_encoder * enc,const VkSubpassDescriptionDepthStencilResolve * val)924 vn_encode_VkSubpassDescriptionDepthStencilResolve(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
925 {
926 assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);
927 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE });
928 vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(enc, val->pNext);
929 vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, val);
930 }
931
932 /* struct VkFragmentShadingRateAttachmentInfoKHR chain */
933
934 static inline size_t
vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR_pnext(const void * val)935 vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR_pnext(const void *val)
936 {
937 /* no known/supported struct */
938 return vn_sizeof_simple_pointer(NULL);
939 }
940
941 static inline size_t
vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR_self(const VkFragmentShadingRateAttachmentInfoKHR * val)942 vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR_self(const VkFragmentShadingRateAttachmentInfoKHR *val)
943 {
944 size_t size = 0;
945 /* skip val->{sType,pNext} */
946 size += vn_sizeof_simple_pointer(val->pFragmentShadingRateAttachment);
947 if (val->pFragmentShadingRateAttachment)
948 size += vn_sizeof_VkAttachmentReference2(val->pFragmentShadingRateAttachment);
949 size += vn_sizeof_VkExtent2D(&val->shadingRateAttachmentTexelSize);
950 return size;
951 }
952
953 static inline size_t
vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR * val)954 vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR *val)
955 {
956 size_t size = 0;
957
958 size += vn_sizeof_VkStructureType(&val->sType);
959 size += vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR_pnext(val->pNext);
960 size += vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR_self(val);
961
962 return size;
963 }
964
965 static inline void
vn_encode_VkFragmentShadingRateAttachmentInfoKHR_pnext(struct vn_cs_encoder * enc,const void * val)966 vn_encode_VkFragmentShadingRateAttachmentInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
967 {
968 /* no known/supported struct */
969 vn_encode_simple_pointer(enc, NULL);
970 }
971
972 static inline void
vn_encode_VkFragmentShadingRateAttachmentInfoKHR_self(struct vn_cs_encoder * enc,const VkFragmentShadingRateAttachmentInfoKHR * val)973 vn_encode_VkFragmentShadingRateAttachmentInfoKHR_self(struct vn_cs_encoder *enc, const VkFragmentShadingRateAttachmentInfoKHR *val)
974 {
975 /* skip val->{sType,pNext} */
976 if (vn_encode_simple_pointer(enc, val->pFragmentShadingRateAttachment))
977 vn_encode_VkAttachmentReference2(enc, val->pFragmentShadingRateAttachment);
978 vn_encode_VkExtent2D(enc, &val->shadingRateAttachmentTexelSize);
979 }
980
981 static inline void
vn_encode_VkFragmentShadingRateAttachmentInfoKHR(struct vn_cs_encoder * enc,const VkFragmentShadingRateAttachmentInfoKHR * val)982 vn_encode_VkFragmentShadingRateAttachmentInfoKHR(struct vn_cs_encoder *enc, const VkFragmentShadingRateAttachmentInfoKHR *val)
983 {
984 assert(val->sType == VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR);
985 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR });
986 vn_encode_VkFragmentShadingRateAttachmentInfoKHR_pnext(enc, val->pNext);
987 vn_encode_VkFragmentShadingRateAttachmentInfoKHR_self(enc, val);
988 }
989
990 /* struct VkSubpassDescription2 chain */
991
992 static inline size_t
vn_sizeof_VkSubpassDescription2_pnext(const void * val)993 vn_sizeof_VkSubpassDescription2_pnext(const void *val)
994 {
995 const VkBaseInStructure *pnext = val;
996 size_t size = 0;
997
998 while (pnext) {
999 switch ((int32_t)pnext->sType) {
1000 case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
1001 size += vn_sizeof_simple_pointer(pnext);
1002 size += vn_sizeof_VkStructureType(&pnext->sType);
1003 size += vn_sizeof_VkSubpassDescription2_pnext(pnext->pNext);
1004 size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self((const VkSubpassDescriptionDepthStencilResolve *)pnext);
1005 return size;
1006 case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
1007 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
1008 break;
1009 size += vn_sizeof_simple_pointer(pnext);
1010 size += vn_sizeof_VkStructureType(&pnext->sType);
1011 size += vn_sizeof_VkSubpassDescription2_pnext(pnext->pNext);
1012 size += vn_sizeof_VkFragmentShadingRateAttachmentInfoKHR_self((const VkFragmentShadingRateAttachmentInfoKHR *)pnext);
1013 return size;
1014 default:
1015 /* ignore unknown/unsupported struct */
1016 break;
1017 }
1018 pnext = pnext->pNext;
1019 }
1020
1021 return vn_sizeof_simple_pointer(NULL);
1022 }
1023
1024 static inline size_t
vn_sizeof_VkSubpassDescription2_self(const VkSubpassDescription2 * val)1025 vn_sizeof_VkSubpassDescription2_self(const VkSubpassDescription2 *val)
1026 {
1027 size_t size = 0;
1028 /* skip val->{sType,pNext} */
1029 size += vn_sizeof_VkFlags(&val->flags);
1030 size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
1031 size += vn_sizeof_uint32_t(&val->viewMask);
1032 size += vn_sizeof_uint32_t(&val->inputAttachmentCount);
1033 if (val->pInputAttachments) {
1034 size += vn_sizeof_array_size(val->inputAttachmentCount);
1035 for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
1036 size += vn_sizeof_VkAttachmentReference2(&val->pInputAttachments[i]);
1037 } else {
1038 size += vn_sizeof_array_size(0);
1039 }
1040 size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
1041 if (val->pColorAttachments) {
1042 size += vn_sizeof_array_size(val->colorAttachmentCount);
1043 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
1044 size += vn_sizeof_VkAttachmentReference2(&val->pColorAttachments[i]);
1045 } else {
1046 size += vn_sizeof_array_size(0);
1047 }
1048 if (val->pResolveAttachments) {
1049 size += vn_sizeof_array_size(val->colorAttachmentCount);
1050 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
1051 size += vn_sizeof_VkAttachmentReference2(&val->pResolveAttachments[i]);
1052 } else {
1053 size += vn_sizeof_array_size(0);
1054 }
1055 size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);
1056 if (val->pDepthStencilAttachment)
1057 size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilAttachment);
1058 size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);
1059 if (val->pPreserveAttachments) {
1060 size += vn_sizeof_array_size(val->preserveAttachmentCount);
1061 size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);
1062 } else {
1063 size += vn_sizeof_array_size(0);
1064 }
1065 return size;
1066 }
1067
1068 static inline size_t
vn_sizeof_VkSubpassDescription2(const VkSubpassDescription2 * val)1069 vn_sizeof_VkSubpassDescription2(const VkSubpassDescription2 *val)
1070 {
1071 size_t size = 0;
1072
1073 size += vn_sizeof_VkStructureType(&val->sType);
1074 size += vn_sizeof_VkSubpassDescription2_pnext(val->pNext);
1075 size += vn_sizeof_VkSubpassDescription2_self(val);
1076
1077 return size;
1078 }
1079
1080 static inline void
vn_encode_VkSubpassDescription2_pnext(struct vn_cs_encoder * enc,const void * val)1081 vn_encode_VkSubpassDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
1082 {
1083 const VkBaseInStructure *pnext = val;
1084
1085 while (pnext) {
1086 switch ((int32_t)pnext->sType) {
1087 case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
1088 vn_encode_simple_pointer(enc, pnext);
1089 vn_encode_VkStructureType(enc, &pnext->sType);
1090 vn_encode_VkSubpassDescription2_pnext(enc, pnext->pNext);
1091 vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, (const VkSubpassDescriptionDepthStencilResolve *)pnext);
1092 return;
1093 case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
1094 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
1095 break;
1096 vn_encode_simple_pointer(enc, pnext);
1097 vn_encode_VkStructureType(enc, &pnext->sType);
1098 vn_encode_VkSubpassDescription2_pnext(enc, pnext->pNext);
1099 vn_encode_VkFragmentShadingRateAttachmentInfoKHR_self(enc, (const VkFragmentShadingRateAttachmentInfoKHR *)pnext);
1100 return;
1101 default:
1102 /* ignore unknown/unsupported struct */
1103 break;
1104 }
1105 pnext = pnext->pNext;
1106 }
1107
1108 vn_encode_simple_pointer(enc, NULL);
1109 }
1110
1111 static inline void
vn_encode_VkSubpassDescription2_self(struct vn_cs_encoder * enc,const VkSubpassDescription2 * val)1112 vn_encode_VkSubpassDescription2_self(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
1113 {
1114 /* skip val->{sType,pNext} */
1115 vn_encode_VkFlags(enc, &val->flags);
1116 vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
1117 vn_encode_uint32_t(enc, &val->viewMask);
1118 vn_encode_uint32_t(enc, &val->inputAttachmentCount);
1119 if (val->pInputAttachments) {
1120 vn_encode_array_size(enc, val->inputAttachmentCount);
1121 for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
1122 vn_encode_VkAttachmentReference2(enc, &val->pInputAttachments[i]);
1123 } else {
1124 vn_encode_array_size(enc, 0);
1125 }
1126 vn_encode_uint32_t(enc, &val->colorAttachmentCount);
1127 if (val->pColorAttachments) {
1128 vn_encode_array_size(enc, val->colorAttachmentCount);
1129 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
1130 vn_encode_VkAttachmentReference2(enc, &val->pColorAttachments[i]);
1131 } else {
1132 vn_encode_array_size(enc, 0);
1133 }
1134 if (val->pResolveAttachments) {
1135 vn_encode_array_size(enc, val->colorAttachmentCount);
1136 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
1137 vn_encode_VkAttachmentReference2(enc, &val->pResolveAttachments[i]);
1138 } else {
1139 vn_encode_array_size(enc, 0);
1140 }
1141 if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))
1142 vn_encode_VkAttachmentReference2(enc, val->pDepthStencilAttachment);
1143 vn_encode_uint32_t(enc, &val->preserveAttachmentCount);
1144 if (val->pPreserveAttachments) {
1145 vn_encode_array_size(enc, val->preserveAttachmentCount);
1146 vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);
1147 } else {
1148 vn_encode_array_size(enc, 0);
1149 }
1150 }
1151
1152 static inline void
vn_encode_VkSubpassDescription2(struct vn_cs_encoder * enc,const VkSubpassDescription2 * val)1153 vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
1154 {
1155 assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2);
1156 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 });
1157 vn_encode_VkSubpassDescription2_pnext(enc, val->pNext);
1158 vn_encode_VkSubpassDescription2_self(enc, val);
1159 }
1160
1161 /* struct VkSubpassDependency2 chain */
1162
1163 static inline size_t
vn_sizeof_VkSubpassDependency2_pnext(const void * val)1164 vn_sizeof_VkSubpassDependency2_pnext(const void *val)
1165 {
1166 const VkBaseInStructure *pnext = val;
1167 size_t size = 0;
1168
1169 while (pnext) {
1170 switch ((int32_t)pnext->sType) {
1171 case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
1172 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
1173 break;
1174 size += vn_sizeof_simple_pointer(pnext);
1175 size += vn_sizeof_VkStructureType(&pnext->sType);
1176 size += vn_sizeof_VkSubpassDependency2_pnext(pnext->pNext);
1177 size += vn_sizeof_VkMemoryBarrier2_self((const VkMemoryBarrier2 *)pnext);
1178 return size;
1179 default:
1180 /* ignore unknown/unsupported struct */
1181 break;
1182 }
1183 pnext = pnext->pNext;
1184 }
1185
1186 return vn_sizeof_simple_pointer(NULL);
1187 }
1188
1189 static inline size_t
vn_sizeof_VkSubpassDependency2_self(const VkSubpassDependency2 * val)1190 vn_sizeof_VkSubpassDependency2_self(const VkSubpassDependency2 *val)
1191 {
1192 size_t size = 0;
1193 /* skip val->{sType,pNext} */
1194 size += vn_sizeof_uint32_t(&val->srcSubpass);
1195 size += vn_sizeof_uint32_t(&val->dstSubpass);
1196 size += vn_sizeof_VkFlags(&val->srcStageMask);
1197 size += vn_sizeof_VkFlags(&val->dstStageMask);
1198 size += vn_sizeof_VkFlags(&val->srcAccessMask);
1199 size += vn_sizeof_VkFlags(&val->dstAccessMask);
1200 size += vn_sizeof_VkFlags(&val->dependencyFlags);
1201 size += vn_sizeof_int32_t(&val->viewOffset);
1202 return size;
1203 }
1204
1205 static inline size_t
vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 * val)1206 vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val)
1207 {
1208 size_t size = 0;
1209
1210 size += vn_sizeof_VkStructureType(&val->sType);
1211 size += vn_sizeof_VkSubpassDependency2_pnext(val->pNext);
1212 size += vn_sizeof_VkSubpassDependency2_self(val);
1213
1214 return size;
1215 }
1216
1217 static inline void
vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder * enc,const void * val)1218 vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val)
1219 {
1220 const VkBaseInStructure *pnext = val;
1221
1222 while (pnext) {
1223 switch ((int32_t)pnext->sType) {
1224 case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
1225 if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
1226 break;
1227 vn_encode_simple_pointer(enc, pnext);
1228 vn_encode_VkStructureType(enc, &pnext->sType);
1229 vn_encode_VkSubpassDependency2_pnext(enc, pnext->pNext);
1230 vn_encode_VkMemoryBarrier2_self(enc, (const VkMemoryBarrier2 *)pnext);
1231 return;
1232 default:
1233 /* ignore unknown/unsupported struct */
1234 break;
1235 }
1236 pnext = pnext->pNext;
1237 }
1238
1239 vn_encode_simple_pointer(enc, NULL);
1240 }
1241
1242 static inline void
vn_encode_VkSubpassDependency2_self(struct vn_cs_encoder * enc,const VkSubpassDependency2 * val)1243 vn_encode_VkSubpassDependency2_self(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
1244 {
1245 /* skip val->{sType,pNext} */
1246 vn_encode_uint32_t(enc, &val->srcSubpass);
1247 vn_encode_uint32_t(enc, &val->dstSubpass);
1248 vn_encode_VkFlags(enc, &val->srcStageMask);
1249 vn_encode_VkFlags(enc, &val->dstStageMask);
1250 vn_encode_VkFlags(enc, &val->srcAccessMask);
1251 vn_encode_VkFlags(enc, &val->dstAccessMask);
1252 vn_encode_VkFlags(enc, &val->dependencyFlags);
1253 vn_encode_int32_t(enc, &val->viewOffset);
1254 }
1255
1256 static inline void
vn_encode_VkSubpassDependency2(struct vn_cs_encoder * enc,const VkSubpassDependency2 * val)1257 vn_encode_VkSubpassDependency2(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
1258 {
1259 assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2);
1260 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 });
1261 vn_encode_VkSubpassDependency2_pnext(enc, val->pNext);
1262 vn_encode_VkSubpassDependency2_self(enc, val);
1263 }
1264
1265 /* struct VkRenderPassCreateInfo2 chain */
1266
1267 static inline size_t
vn_sizeof_VkRenderPassCreateInfo2_pnext(const void * val)1268 vn_sizeof_VkRenderPassCreateInfo2_pnext(const void *val)
1269 {
1270 /* no known/supported struct */
1271 return vn_sizeof_simple_pointer(NULL);
1272 }
1273
1274 static inline size_t
vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 * val)1275 vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 *val)
1276 {
1277 size_t size = 0;
1278 /* skip val->{sType,pNext} */
1279 size += vn_sizeof_VkFlags(&val->flags);
1280 size += vn_sizeof_uint32_t(&val->attachmentCount);
1281 if (val->pAttachments) {
1282 size += vn_sizeof_array_size(val->attachmentCount);
1283 for (uint32_t i = 0; i < val->attachmentCount; i++)
1284 size += vn_sizeof_VkAttachmentDescription2(&val->pAttachments[i]);
1285 } else {
1286 size += vn_sizeof_array_size(0);
1287 }
1288 size += vn_sizeof_uint32_t(&val->subpassCount);
1289 if (val->pSubpasses) {
1290 size += vn_sizeof_array_size(val->subpassCount);
1291 for (uint32_t i = 0; i < val->subpassCount; i++)
1292 size += vn_sizeof_VkSubpassDescription2(&val->pSubpasses[i]);
1293 } else {
1294 size += vn_sizeof_array_size(0);
1295 }
1296 size += vn_sizeof_uint32_t(&val->dependencyCount);
1297 if (val->pDependencies) {
1298 size += vn_sizeof_array_size(val->dependencyCount);
1299 for (uint32_t i = 0; i < val->dependencyCount; i++)
1300 size += vn_sizeof_VkSubpassDependency2(&val->pDependencies[i]);
1301 } else {
1302 size += vn_sizeof_array_size(0);
1303 }
1304 size += vn_sizeof_uint32_t(&val->correlatedViewMaskCount);
1305 if (val->pCorrelatedViewMasks) {
1306 size += vn_sizeof_array_size(val->correlatedViewMaskCount);
1307 size += vn_sizeof_uint32_t_array(val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
1308 } else {
1309 size += vn_sizeof_array_size(0);
1310 }
1311 return size;
1312 }
1313
1314 static inline size_t
vn_sizeof_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 * val)1315 vn_sizeof_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 *val)
1316 {
1317 size_t size = 0;
1318
1319 size += vn_sizeof_VkStructureType(&val->sType);
1320 size += vn_sizeof_VkRenderPassCreateInfo2_pnext(val->pNext);
1321 size += vn_sizeof_VkRenderPassCreateInfo2_self(val);
1322
1323 return size;
1324 }
1325
1326 static inline void
vn_encode_VkRenderPassCreateInfo2_pnext(struct vn_cs_encoder * enc,const void * val)1327 vn_encode_VkRenderPassCreateInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
1328 {
1329 /* no known/supported struct */
1330 vn_encode_simple_pointer(enc, NULL);
1331 }
1332
1333 static inline void
vn_encode_VkRenderPassCreateInfo2_self(struct vn_cs_encoder * enc,const VkRenderPassCreateInfo2 * val)1334 vn_encode_VkRenderPassCreateInfo2_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
1335 {
1336 /* skip val->{sType,pNext} */
1337 vn_encode_VkFlags(enc, &val->flags);
1338 vn_encode_uint32_t(enc, &val->attachmentCount);
1339 if (val->pAttachments) {
1340 vn_encode_array_size(enc, val->attachmentCount);
1341 for (uint32_t i = 0; i < val->attachmentCount; i++)
1342 vn_encode_VkAttachmentDescription2(enc, &val->pAttachments[i]);
1343 } else {
1344 vn_encode_array_size(enc, 0);
1345 }
1346 vn_encode_uint32_t(enc, &val->subpassCount);
1347 if (val->pSubpasses) {
1348 vn_encode_array_size(enc, val->subpassCount);
1349 for (uint32_t i = 0; i < val->subpassCount; i++)
1350 vn_encode_VkSubpassDescription2(enc, &val->pSubpasses[i]);
1351 } else {
1352 vn_encode_array_size(enc, 0);
1353 }
1354 vn_encode_uint32_t(enc, &val->dependencyCount);
1355 if (val->pDependencies) {
1356 vn_encode_array_size(enc, val->dependencyCount);
1357 for (uint32_t i = 0; i < val->dependencyCount; i++)
1358 vn_encode_VkSubpassDependency2(enc, &val->pDependencies[i]);
1359 } else {
1360 vn_encode_array_size(enc, 0);
1361 }
1362 vn_encode_uint32_t(enc, &val->correlatedViewMaskCount);
1363 if (val->pCorrelatedViewMasks) {
1364 vn_encode_array_size(enc, val->correlatedViewMaskCount);
1365 vn_encode_uint32_t_array(enc, val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
1366 } else {
1367 vn_encode_array_size(enc, 0);
1368 }
1369 }
1370
1371 static inline void
vn_encode_VkRenderPassCreateInfo2(struct vn_cs_encoder * enc,const VkRenderPassCreateInfo2 * val)1372 vn_encode_VkRenderPassCreateInfo2(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
1373 {
1374 assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2);
1375 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 });
1376 vn_encode_VkRenderPassCreateInfo2_pnext(enc, val->pNext);
1377 vn_encode_VkRenderPassCreateInfo2_self(enc, val);
1378 }
1379
vn_sizeof_vkCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1380 static inline size_t vn_sizeof_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1381 {
1382 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
1383 const VkFlags cmd_flags = 0;
1384 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1385
1386 cmd_size += vn_sizeof_VkDevice(&device);
1387 cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
1388 if (pCreateInfo)
1389 cmd_size += vn_sizeof_VkRenderPassCreateInfo(pCreateInfo);
1390 cmd_size += vn_sizeof_simple_pointer(pAllocator);
1391 if (pAllocator)
1392 assert(false);
1393 cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1394 if (pRenderPass)
1395 cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1396
1397 return cmd_size;
1398 }
1399
vn_encode_vkCreateRenderPass(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1400 static inline void vn_encode_vkCreateRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1401 {
1402 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
1403
1404 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1405 vn_encode_VkFlags(enc, &cmd_flags);
1406
1407 vn_encode_VkDevice(enc, &device);
1408 if (vn_encode_simple_pointer(enc, pCreateInfo))
1409 vn_encode_VkRenderPassCreateInfo(enc, pCreateInfo);
1410 if (vn_encode_simple_pointer(enc, pAllocator))
1411 assert(false);
1412 if (vn_encode_simple_pointer(enc, pRenderPass))
1413 vn_encode_VkRenderPass(enc, pRenderPass);
1414 }
1415
vn_sizeof_vkCreateRenderPass_reply(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1416 static inline size_t vn_sizeof_vkCreateRenderPass_reply(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1417 {
1418 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
1419 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1420
1421 VkResult ret;
1422 cmd_size += vn_sizeof_VkResult(&ret);
1423 /* skip device */
1424 /* skip pCreateInfo */
1425 /* skip pAllocator */
1426 cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1427 if (pRenderPass)
1428 cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1429
1430 return cmd_size;
1431 }
1432
vn_decode_vkCreateRenderPass_reply(struct vn_cs_decoder * dec,VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1433 static inline VkResult vn_decode_vkCreateRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1434 {
1435 VkCommandTypeEXT command_type;
1436 vn_decode_VkCommandTypeEXT(dec, &command_type);
1437 assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass_EXT);
1438
1439 VkResult ret;
1440 vn_decode_VkResult(dec, &ret);
1441 /* skip device */
1442 /* skip pCreateInfo */
1443 /* skip pAllocator */
1444 if (vn_decode_simple_pointer(dec)) {
1445 vn_decode_VkRenderPass(dec, pRenderPass);
1446 } else {
1447 pRenderPass = NULL;
1448 }
1449
1450 return ret;
1451 }
1452
vn_sizeof_vkDestroyRenderPass(VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1453 static inline size_t vn_sizeof_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1454 {
1455 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
1456 const VkFlags cmd_flags = 0;
1457 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1458
1459 cmd_size += vn_sizeof_VkDevice(&device);
1460 cmd_size += vn_sizeof_VkRenderPass(&renderPass);
1461 cmd_size += vn_sizeof_simple_pointer(pAllocator);
1462 if (pAllocator)
1463 assert(false);
1464
1465 return cmd_size;
1466 }
1467
vn_encode_vkDestroyRenderPass(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1468 static inline void vn_encode_vkDestroyRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1469 {
1470 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
1471
1472 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1473 vn_encode_VkFlags(enc, &cmd_flags);
1474
1475 vn_encode_VkDevice(enc, &device);
1476 vn_encode_VkRenderPass(enc, &renderPass);
1477 if (vn_encode_simple_pointer(enc, pAllocator))
1478 assert(false);
1479 }
1480
vn_sizeof_vkDestroyRenderPass_reply(VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1481 static inline size_t vn_sizeof_vkDestroyRenderPass_reply(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1482 {
1483 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
1484 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1485
1486 /* skip device */
1487 /* skip renderPass */
1488 /* skip pAllocator */
1489
1490 return cmd_size;
1491 }
1492
vn_decode_vkDestroyRenderPass_reply(struct vn_cs_decoder * dec,VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1493 static inline void vn_decode_vkDestroyRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1494 {
1495 VkCommandTypeEXT command_type;
1496 vn_decode_VkCommandTypeEXT(dec, &command_type);
1497 assert(command_type == VK_COMMAND_TYPE_vkDestroyRenderPass_EXT);
1498
1499 /* skip device */
1500 /* skip renderPass */
1501 /* skip pAllocator */
1502 }
1503
vn_sizeof_vkGetRenderAreaGranularity(VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity)1504 static inline size_t vn_sizeof_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1505 {
1506 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
1507 const VkFlags cmd_flags = 0;
1508 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1509
1510 cmd_size += vn_sizeof_VkDevice(&device);
1511 cmd_size += vn_sizeof_VkRenderPass(&renderPass);
1512 cmd_size += vn_sizeof_simple_pointer(pGranularity);
1513 if (pGranularity)
1514 cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity);
1515
1516 return cmd_size;
1517 }
1518
vn_encode_vkGetRenderAreaGranularity(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity)1519 static inline void vn_encode_vkGetRenderAreaGranularity(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1520 {
1521 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
1522
1523 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1524 vn_encode_VkFlags(enc, &cmd_flags);
1525
1526 vn_encode_VkDevice(enc, &device);
1527 vn_encode_VkRenderPass(enc, &renderPass);
1528 if (vn_encode_simple_pointer(enc, pGranularity))
1529 vn_encode_VkExtent2D_partial(enc, pGranularity);
1530 }
1531
vn_sizeof_vkGetRenderAreaGranularity_reply(VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity)1532 static inline size_t vn_sizeof_vkGetRenderAreaGranularity_reply(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1533 {
1534 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
1535 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1536
1537 /* skip device */
1538 /* skip renderPass */
1539 cmd_size += vn_sizeof_simple_pointer(pGranularity);
1540 if (pGranularity)
1541 cmd_size += vn_sizeof_VkExtent2D(pGranularity);
1542
1543 return cmd_size;
1544 }
1545
vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decoder * dec,VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity)1546 static inline void vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1547 {
1548 VkCommandTypeEXT command_type;
1549 vn_decode_VkCommandTypeEXT(dec, &command_type);
1550 assert(command_type == VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT);
1551
1552 /* skip device */
1553 /* skip renderPass */
1554 if (vn_decode_simple_pointer(dec)) {
1555 vn_decode_VkExtent2D(dec, pGranularity);
1556 } else {
1557 pGranularity = NULL;
1558 }
1559 }
1560
vn_sizeof_vkGetRenderingAreaGranularityKHR(VkDevice device,const VkRenderingAreaInfoKHR * pRenderingAreaInfo,VkExtent2D * pGranularity)1561 static inline size_t vn_sizeof_vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
1562 {
1563 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT;
1564 const VkFlags cmd_flags = 0;
1565 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1566
1567 cmd_size += vn_sizeof_VkDevice(&device);
1568 cmd_size += vn_sizeof_simple_pointer(pRenderingAreaInfo);
1569 if (pRenderingAreaInfo)
1570 cmd_size += vn_sizeof_VkRenderingAreaInfoKHR(pRenderingAreaInfo);
1571 cmd_size += vn_sizeof_simple_pointer(pGranularity);
1572 if (pGranularity)
1573 cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity);
1574
1575 return cmd_size;
1576 }
1577
vn_encode_vkGetRenderingAreaGranularityKHR(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkRenderingAreaInfoKHR * pRenderingAreaInfo,VkExtent2D * pGranularity)1578 static inline void vn_encode_vkGetRenderingAreaGranularityKHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
1579 {
1580 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT;
1581
1582 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1583 vn_encode_VkFlags(enc, &cmd_flags);
1584
1585 vn_encode_VkDevice(enc, &device);
1586 if (vn_encode_simple_pointer(enc, pRenderingAreaInfo))
1587 vn_encode_VkRenderingAreaInfoKHR(enc, pRenderingAreaInfo);
1588 if (vn_encode_simple_pointer(enc, pGranularity))
1589 vn_encode_VkExtent2D_partial(enc, pGranularity);
1590 }
1591
vn_sizeof_vkGetRenderingAreaGranularityKHR_reply(VkDevice device,const VkRenderingAreaInfoKHR * pRenderingAreaInfo,VkExtent2D * pGranularity)1592 static inline size_t vn_sizeof_vkGetRenderingAreaGranularityKHR_reply(VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
1593 {
1594 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT;
1595 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1596
1597 /* skip device */
1598 /* skip pRenderingAreaInfo */
1599 cmd_size += vn_sizeof_simple_pointer(pGranularity);
1600 if (pGranularity)
1601 cmd_size += vn_sizeof_VkExtent2D(pGranularity);
1602
1603 return cmd_size;
1604 }
1605
vn_decode_vkGetRenderingAreaGranularityKHR_reply(struct vn_cs_decoder * dec,VkDevice device,const VkRenderingAreaInfoKHR * pRenderingAreaInfo,VkExtent2D * pGranularity)1606 static inline void vn_decode_vkGetRenderingAreaGranularityKHR_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
1607 {
1608 VkCommandTypeEXT command_type;
1609 vn_decode_VkCommandTypeEXT(dec, &command_type);
1610 assert(command_type == VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT);
1611
1612 /* skip device */
1613 /* skip pRenderingAreaInfo */
1614 if (vn_decode_simple_pointer(dec)) {
1615 vn_decode_VkExtent2D(dec, pGranularity);
1616 } else {
1617 pGranularity = NULL;
1618 }
1619 }
1620
vn_sizeof_vkCreateRenderPass2(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1621 static inline size_t vn_sizeof_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1622 {
1623 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
1624 const VkFlags cmd_flags = 0;
1625 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1626
1627 cmd_size += vn_sizeof_VkDevice(&device);
1628 cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
1629 if (pCreateInfo)
1630 cmd_size += vn_sizeof_VkRenderPassCreateInfo2(pCreateInfo);
1631 cmd_size += vn_sizeof_simple_pointer(pAllocator);
1632 if (pAllocator)
1633 assert(false);
1634 cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1635 if (pRenderPass)
1636 cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1637
1638 return cmd_size;
1639 }
1640
vn_encode_vkCreateRenderPass2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1641 static inline void vn_encode_vkCreateRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1642 {
1643 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
1644
1645 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1646 vn_encode_VkFlags(enc, &cmd_flags);
1647
1648 vn_encode_VkDevice(enc, &device);
1649 if (vn_encode_simple_pointer(enc, pCreateInfo))
1650 vn_encode_VkRenderPassCreateInfo2(enc, pCreateInfo);
1651 if (vn_encode_simple_pointer(enc, pAllocator))
1652 assert(false);
1653 if (vn_encode_simple_pointer(enc, pRenderPass))
1654 vn_encode_VkRenderPass(enc, pRenderPass);
1655 }
1656
vn_sizeof_vkCreateRenderPass2_reply(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1657 static inline size_t vn_sizeof_vkCreateRenderPass2_reply(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1658 {
1659 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
1660 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1661
1662 VkResult ret;
1663 cmd_size += vn_sizeof_VkResult(&ret);
1664 /* skip device */
1665 /* skip pCreateInfo */
1666 /* skip pAllocator */
1667 cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1668 if (pRenderPass)
1669 cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1670
1671 return cmd_size;
1672 }
1673
vn_decode_vkCreateRenderPass2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1674 static inline VkResult vn_decode_vkCreateRenderPass2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1675 {
1676 VkCommandTypeEXT command_type;
1677 vn_decode_VkCommandTypeEXT(dec, &command_type);
1678 assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass2_EXT);
1679
1680 VkResult ret;
1681 vn_decode_VkResult(dec, &ret);
1682 /* skip device */
1683 /* skip pCreateInfo */
1684 /* skip pAllocator */
1685 if (vn_decode_simple_pointer(dec)) {
1686 vn_decode_VkRenderPass(dec, pRenderPass);
1687 } else {
1688 pRenderPass = NULL;
1689 }
1690
1691 return ret;
1692 }
1693
vn_submit_vkCreateRenderPass(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass,struct vn_ring_submit_command * submit)1694 static inline void vn_submit_vkCreateRenderPass(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_ring_submit_command *submit)
1695 {
1696 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1697 void *cmd_data = local_cmd_data;
1698 size_t cmd_size = vn_sizeof_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
1699 if (cmd_size > sizeof(local_cmd_data)) {
1700 cmd_data = malloc(cmd_size);
1701 if (!cmd_data)
1702 cmd_size = 0;
1703 }
1704 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
1705
1706 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1707 if (cmd_size) {
1708 vn_encode_vkCreateRenderPass(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
1709 vn_ring_submit_command(vn_ring, submit);
1710 if (cmd_data != local_cmd_data)
1711 free(cmd_data);
1712 }
1713 }
1714
vn_submit_vkDestroyRenderPass(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator,struct vn_ring_submit_command * submit)1715 static inline void vn_submit_vkDestroyRenderPass(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, struct vn_ring_submit_command *submit)
1716 {
1717 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1718 void *cmd_data = local_cmd_data;
1719 size_t cmd_size = vn_sizeof_vkDestroyRenderPass(device, renderPass, pAllocator);
1720 if (cmd_size > sizeof(local_cmd_data)) {
1721 cmd_data = malloc(cmd_size);
1722 if (!cmd_data)
1723 cmd_size = 0;
1724 }
1725 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0;
1726
1727 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1728 if (cmd_size) {
1729 vn_encode_vkDestroyRenderPass(enc, cmd_flags, device, renderPass, pAllocator);
1730 vn_ring_submit_command(vn_ring, submit);
1731 if (cmd_data != local_cmd_data)
1732 free(cmd_data);
1733 }
1734 }
1735
vn_submit_vkGetRenderAreaGranularity(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity,struct vn_ring_submit_command * submit)1736 static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, struct vn_ring_submit_command *submit)
1737 {
1738 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1739 void *cmd_data = local_cmd_data;
1740 size_t cmd_size = vn_sizeof_vkGetRenderAreaGranularity(device, renderPass, pGranularity);
1741 if (cmd_size > sizeof(local_cmd_data)) {
1742 cmd_data = malloc(cmd_size);
1743 if (!cmd_data)
1744 cmd_size = 0;
1745 }
1746 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0;
1747
1748 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1749 if (cmd_size) {
1750 vn_encode_vkGetRenderAreaGranularity(enc, cmd_flags, device, renderPass, pGranularity);
1751 vn_ring_submit_command(vn_ring, submit);
1752 if (cmd_data != local_cmd_data)
1753 free(cmd_data);
1754 }
1755 }
1756
vn_submit_vkGetRenderingAreaGranularityKHR(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkRenderingAreaInfoKHR * pRenderingAreaInfo,VkExtent2D * pGranularity,struct vn_ring_submit_command * submit)1757 static inline void vn_submit_vkGetRenderingAreaGranularityKHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity, struct vn_ring_submit_command *submit)
1758 {
1759 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1760 void *cmd_data = local_cmd_data;
1761 size_t cmd_size = vn_sizeof_vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity);
1762 if (cmd_size > sizeof(local_cmd_data)) {
1763 cmd_data = malloc(cmd_size);
1764 if (!cmd_data)
1765 cmd_size = 0;
1766 }
1767 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderingAreaGranularityKHR_reply(device, pRenderingAreaInfo, pGranularity) : 0;
1768
1769 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1770 if (cmd_size) {
1771 vn_encode_vkGetRenderingAreaGranularityKHR(enc, cmd_flags, device, pRenderingAreaInfo, pGranularity);
1772 vn_ring_submit_command(vn_ring, submit);
1773 if (cmd_data != local_cmd_data)
1774 free(cmd_data);
1775 }
1776 }
1777
vn_submit_vkCreateRenderPass2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass,struct vn_ring_submit_command * submit)1778 static inline void vn_submit_vkCreateRenderPass2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_ring_submit_command *submit)
1779 {
1780 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1781 void *cmd_data = local_cmd_data;
1782 size_t cmd_size = vn_sizeof_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
1783 if (cmd_size > sizeof(local_cmd_data)) {
1784 cmd_data = malloc(cmd_size);
1785 if (!cmd_data)
1786 cmd_size = 0;
1787 }
1788 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
1789
1790 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
1791 if (cmd_size) {
1792 vn_encode_vkCreateRenderPass2(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
1793 vn_ring_submit_command(vn_ring, submit);
1794 if (cmd_data != local_cmd_data)
1795 free(cmd_data);
1796 }
1797 }
1798
vn_call_vkCreateRenderPass(struct vn_ring * vn_ring,VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1799 static inline VkResult vn_call_vkCreateRenderPass(struct vn_ring *vn_ring, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1800 {
1801 VN_TRACE_FUNC();
1802
1803 struct vn_ring_submit_command submit;
1804 vn_submit_vkCreateRenderPass(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1805 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1806 if (dec) {
1807 const VkResult ret = vn_decode_vkCreateRenderPass_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);
1808 vn_ring_free_command_reply(vn_ring, &submit);
1809 return ret;
1810 } else {
1811 return VK_ERROR_OUT_OF_HOST_MEMORY;
1812 }
1813 }
1814
vn_async_vkCreateRenderPass(struct vn_ring * vn_ring,VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1815 static inline void vn_async_vkCreateRenderPass(struct vn_ring *vn_ring, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1816 {
1817 struct vn_ring_submit_command submit;
1818 vn_submit_vkCreateRenderPass(vn_ring, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1819 }
1820
vn_call_vkDestroyRenderPass(struct vn_ring * vn_ring,VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1821 static inline void vn_call_vkDestroyRenderPass(struct vn_ring *vn_ring, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1822 {
1823 VN_TRACE_FUNC();
1824
1825 struct vn_ring_submit_command submit;
1826 vn_submit_vkDestroyRenderPass(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pAllocator, &submit);
1827 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1828 if (dec) {
1829 vn_decode_vkDestroyRenderPass_reply(dec, device, renderPass, pAllocator);
1830 vn_ring_free_command_reply(vn_ring, &submit);
1831 }
1832 }
1833
vn_async_vkDestroyRenderPass(struct vn_ring * vn_ring,VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1834 static inline void vn_async_vkDestroyRenderPass(struct vn_ring *vn_ring, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1835 {
1836 struct vn_ring_submit_command submit;
1837 vn_submit_vkDestroyRenderPass(vn_ring, 0, device, renderPass, pAllocator, &submit);
1838 }
1839
vn_call_vkGetRenderAreaGranularity(struct vn_ring * vn_ring,VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity)1840 static inline void vn_call_vkGetRenderAreaGranularity(struct vn_ring *vn_ring, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1841 {
1842 VN_TRACE_FUNC();
1843
1844 struct vn_ring_submit_command submit;
1845 vn_submit_vkGetRenderAreaGranularity(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pGranularity, &submit);
1846 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1847 if (dec) {
1848 vn_decode_vkGetRenderAreaGranularity_reply(dec, device, renderPass, pGranularity);
1849 vn_ring_free_command_reply(vn_ring, &submit);
1850 }
1851 }
1852
vn_async_vkGetRenderAreaGranularity(struct vn_ring * vn_ring,VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity)1853 static inline void vn_async_vkGetRenderAreaGranularity(struct vn_ring *vn_ring, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1854 {
1855 struct vn_ring_submit_command submit;
1856 vn_submit_vkGetRenderAreaGranularity(vn_ring, 0, device, renderPass, pGranularity, &submit);
1857 }
1858
vn_call_vkGetRenderingAreaGranularityKHR(struct vn_ring * vn_ring,VkDevice device,const VkRenderingAreaInfoKHR * pRenderingAreaInfo,VkExtent2D * pGranularity)1859 static inline void vn_call_vkGetRenderingAreaGranularityKHR(struct vn_ring *vn_ring, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
1860 {
1861 VN_TRACE_FUNC();
1862
1863 struct vn_ring_submit_command submit;
1864 vn_submit_vkGetRenderingAreaGranularityKHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pRenderingAreaInfo, pGranularity, &submit);
1865 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1866 if (dec) {
1867 vn_decode_vkGetRenderingAreaGranularityKHR_reply(dec, device, pRenderingAreaInfo, pGranularity);
1868 vn_ring_free_command_reply(vn_ring, &submit);
1869 }
1870 }
1871
vn_async_vkGetRenderingAreaGranularityKHR(struct vn_ring * vn_ring,VkDevice device,const VkRenderingAreaInfoKHR * pRenderingAreaInfo,VkExtent2D * pGranularity)1872 static inline void vn_async_vkGetRenderingAreaGranularityKHR(struct vn_ring *vn_ring, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
1873 {
1874 struct vn_ring_submit_command submit;
1875 vn_submit_vkGetRenderingAreaGranularityKHR(vn_ring, 0, device, pRenderingAreaInfo, pGranularity, &submit);
1876 }
1877
vn_call_vkCreateRenderPass2(struct vn_ring * vn_ring,VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1878 static inline VkResult vn_call_vkCreateRenderPass2(struct vn_ring *vn_ring, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1879 {
1880 VN_TRACE_FUNC();
1881
1882 struct vn_ring_submit_command submit;
1883 vn_submit_vkCreateRenderPass2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1884 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
1885 if (dec) {
1886 const VkResult ret = vn_decode_vkCreateRenderPass2_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);
1887 vn_ring_free_command_reply(vn_ring, &submit);
1888 return ret;
1889 } else {
1890 return VK_ERROR_OUT_OF_HOST_MEMORY;
1891 }
1892 }
1893
vn_async_vkCreateRenderPass2(struct vn_ring * vn_ring,VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1894 static inline void vn_async_vkCreateRenderPass2(struct vn_ring *vn_ring, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1895 {
1896 struct vn_ring_submit_command submit;
1897 vn_submit_vkCreateRenderPass2(vn_ring, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1898 }
1899
1900 #endif /* VN_PROTOCOL_DRIVER_RENDER_PASS_H */
1901