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_instance.h"
12#include "vn_protocol_driver_structs.h"
13
14/* struct VkAttachmentDescription */
15
16static inline size_t
17vn_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
32static inline void
33vn_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
48static inline size_t
49vn_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
57static inline void
58vn_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
66static inline size_t
67vn_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
108static inline void
109vn_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
149static inline size_t
150vn_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
163static inline void
164vn_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
177static inline size_t
178vn_sizeof_VkRenderPassMultiviewCreateInfo_pnext(const void *val)
179{
180    /* no known/supported struct */
181    return vn_sizeof_simple_pointer(NULL);
182}
183
184static inline size_t
185vn_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
213static inline size_t
214vn_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
225static inline void
226vn_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
232static inline void
233vn_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
259static inline void
260vn_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
270static inline size_t
271vn_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
280static inline void
281vn_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
290static inline size_t
291vn_sizeof_VkRenderPassInputAttachmentAspectCreateInfo_pnext(const void *val)
292{
293    /* no known/supported struct */
294    return vn_sizeof_simple_pointer(NULL);
295}
296
297static inline size_t
298vn_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
313static inline size_t
314vn_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
325static inline void
326vn_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
332static inline void
333vn_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
346static inline void
347vn_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
357static inline size_t
358vn_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
387static inline size_t
388vn_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
420static inline size_t
421vn_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
432static inline void
433vn_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
461static inline void
462vn_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
492static inline void
493vn_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 VkAttachmentDescriptionStencilLayout chain */
502
503static inline size_t
504vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(const void *val)
505{
506    /* no known/supported struct */
507    return vn_sizeof_simple_pointer(NULL);
508}
509
510static inline size_t
511vn_sizeof_VkAttachmentDescriptionStencilLayout_self(const VkAttachmentDescriptionStencilLayout *val)
512{
513    size_t size = 0;
514    /* skip val->{sType,pNext} */
515    size += vn_sizeof_VkImageLayout(&val->stencilInitialLayout);
516    size += vn_sizeof_VkImageLayout(&val->stencilFinalLayout);
517    return size;
518}
519
520static inline size_t
521vn_sizeof_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout *val)
522{
523    size_t size = 0;
524
525    size += vn_sizeof_VkStructureType(&val->sType);
526    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_pnext(val->pNext);
527    size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self(val);
528
529    return size;
530}
531
532static inline void
533vn_encode_VkAttachmentDescriptionStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
534{
535    /* no known/supported struct */
536    vn_encode_simple_pointer(enc, NULL);
537}
538
539static inline void
540vn_encode_VkAttachmentDescriptionStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
541{
542    /* skip val->{sType,pNext} */
543    vn_encode_VkImageLayout(enc, &val->stencilInitialLayout);
544    vn_encode_VkImageLayout(enc, &val->stencilFinalLayout);
545}
546
547static inline void
548vn_encode_VkAttachmentDescriptionStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentDescriptionStencilLayout *val)
549{
550    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);
551    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT });
552    vn_encode_VkAttachmentDescriptionStencilLayout_pnext(enc, val->pNext);
553    vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, val);
554}
555
556/* struct VkAttachmentDescription2 chain */
557
558static inline size_t
559vn_sizeof_VkAttachmentDescription2_pnext(const void *val)
560{
561    const VkBaseInStructure *pnext = val;
562    size_t size = 0;
563
564    while (pnext) {
565        switch ((int32_t)pnext->sType) {
566        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
567            size += vn_sizeof_simple_pointer(pnext);
568            size += vn_sizeof_VkStructureType(&pnext->sType);
569            size += vn_sizeof_VkAttachmentDescription2_pnext(pnext->pNext);
570            size += vn_sizeof_VkAttachmentDescriptionStencilLayout_self((const VkAttachmentDescriptionStencilLayout *)pnext);
571            return size;
572        default:
573            /* ignore unknown/unsupported struct */
574            break;
575        }
576        pnext = pnext->pNext;
577    }
578
579    return vn_sizeof_simple_pointer(NULL);
580}
581
582static inline size_t
583vn_sizeof_VkAttachmentDescription2_self(const VkAttachmentDescription2 *val)
584{
585    size_t size = 0;
586    /* skip val->{sType,pNext} */
587    size += vn_sizeof_VkFlags(&val->flags);
588    size += vn_sizeof_VkFormat(&val->format);
589    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
590    size += vn_sizeof_VkAttachmentLoadOp(&val->loadOp);
591    size += vn_sizeof_VkAttachmentStoreOp(&val->storeOp);
592    size += vn_sizeof_VkAttachmentLoadOp(&val->stencilLoadOp);
593    size += vn_sizeof_VkAttachmentStoreOp(&val->stencilStoreOp);
594    size += vn_sizeof_VkImageLayout(&val->initialLayout);
595    size += vn_sizeof_VkImageLayout(&val->finalLayout);
596    return size;
597}
598
599static inline size_t
600vn_sizeof_VkAttachmentDescription2(const VkAttachmentDescription2 *val)
601{
602    size_t size = 0;
603
604    size += vn_sizeof_VkStructureType(&val->sType);
605    size += vn_sizeof_VkAttachmentDescription2_pnext(val->pNext);
606    size += vn_sizeof_VkAttachmentDescription2_self(val);
607
608    return size;
609}
610
611static inline void
612vn_encode_VkAttachmentDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
613{
614    const VkBaseInStructure *pnext = val;
615
616    while (pnext) {
617        switch ((int32_t)pnext->sType) {
618        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
619            vn_encode_simple_pointer(enc, pnext);
620            vn_encode_VkStructureType(enc, &pnext->sType);
621            vn_encode_VkAttachmentDescription2_pnext(enc, pnext->pNext);
622            vn_encode_VkAttachmentDescriptionStencilLayout_self(enc, (const VkAttachmentDescriptionStencilLayout *)pnext);
623            return;
624        default:
625            /* ignore unknown/unsupported struct */
626            break;
627        }
628        pnext = pnext->pNext;
629    }
630
631    vn_encode_simple_pointer(enc, NULL);
632}
633
634static inline void
635vn_encode_VkAttachmentDescription2_self(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
636{
637    /* skip val->{sType,pNext} */
638    vn_encode_VkFlags(enc, &val->flags);
639    vn_encode_VkFormat(enc, &val->format);
640    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
641    vn_encode_VkAttachmentLoadOp(enc, &val->loadOp);
642    vn_encode_VkAttachmentStoreOp(enc, &val->storeOp);
643    vn_encode_VkAttachmentLoadOp(enc, &val->stencilLoadOp);
644    vn_encode_VkAttachmentStoreOp(enc, &val->stencilStoreOp);
645    vn_encode_VkImageLayout(enc, &val->initialLayout);
646    vn_encode_VkImageLayout(enc, &val->finalLayout);
647}
648
649static inline void
650vn_encode_VkAttachmentDescription2(struct vn_cs_encoder *enc, const VkAttachmentDescription2 *val)
651{
652    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2);
653    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 });
654    vn_encode_VkAttachmentDescription2_pnext(enc, val->pNext);
655    vn_encode_VkAttachmentDescription2_self(enc, val);
656}
657
658/* struct VkAttachmentReferenceStencilLayout chain */
659
660static inline size_t
661vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(const void *val)
662{
663    /* no known/supported struct */
664    return vn_sizeof_simple_pointer(NULL);
665}
666
667static inline size_t
668vn_sizeof_VkAttachmentReferenceStencilLayout_self(const VkAttachmentReferenceStencilLayout *val)
669{
670    size_t size = 0;
671    /* skip val->{sType,pNext} */
672    size += vn_sizeof_VkImageLayout(&val->stencilLayout);
673    return size;
674}
675
676static inline size_t
677vn_sizeof_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout *val)
678{
679    size_t size = 0;
680
681    size += vn_sizeof_VkStructureType(&val->sType);
682    size += vn_sizeof_VkAttachmentReferenceStencilLayout_pnext(val->pNext);
683    size += vn_sizeof_VkAttachmentReferenceStencilLayout_self(val);
684
685    return size;
686}
687
688static inline void
689vn_encode_VkAttachmentReferenceStencilLayout_pnext(struct vn_cs_encoder *enc, const void *val)
690{
691    /* no known/supported struct */
692    vn_encode_simple_pointer(enc, NULL);
693}
694
695static inline void
696vn_encode_VkAttachmentReferenceStencilLayout_self(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
697{
698    /* skip val->{sType,pNext} */
699    vn_encode_VkImageLayout(enc, &val->stencilLayout);
700}
701
702static inline void
703vn_encode_VkAttachmentReferenceStencilLayout(struct vn_cs_encoder *enc, const VkAttachmentReferenceStencilLayout *val)
704{
705    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT);
706    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT });
707    vn_encode_VkAttachmentReferenceStencilLayout_pnext(enc, val->pNext);
708    vn_encode_VkAttachmentReferenceStencilLayout_self(enc, val);
709}
710
711/* struct VkAttachmentReference2 chain */
712
713static inline size_t
714vn_sizeof_VkAttachmentReference2_pnext(const void *val)
715{
716    const VkBaseInStructure *pnext = val;
717    size_t size = 0;
718
719    while (pnext) {
720        switch ((int32_t)pnext->sType) {
721        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
722            size += vn_sizeof_simple_pointer(pnext);
723            size += vn_sizeof_VkStructureType(&pnext->sType);
724            size += vn_sizeof_VkAttachmentReference2_pnext(pnext->pNext);
725            size += vn_sizeof_VkAttachmentReferenceStencilLayout_self((const VkAttachmentReferenceStencilLayout *)pnext);
726            return size;
727        default:
728            /* ignore unknown/unsupported struct */
729            break;
730        }
731        pnext = pnext->pNext;
732    }
733
734    return vn_sizeof_simple_pointer(NULL);
735}
736
737static inline size_t
738vn_sizeof_VkAttachmentReference2_self(const VkAttachmentReference2 *val)
739{
740    size_t size = 0;
741    /* skip val->{sType,pNext} */
742    size += vn_sizeof_uint32_t(&val->attachment);
743    size += vn_sizeof_VkImageLayout(&val->layout);
744    size += vn_sizeof_VkFlags(&val->aspectMask);
745    return size;
746}
747
748static inline size_t
749vn_sizeof_VkAttachmentReference2(const VkAttachmentReference2 *val)
750{
751    size_t size = 0;
752
753    size += vn_sizeof_VkStructureType(&val->sType);
754    size += vn_sizeof_VkAttachmentReference2_pnext(val->pNext);
755    size += vn_sizeof_VkAttachmentReference2_self(val);
756
757    return size;
758}
759
760static inline void
761vn_encode_VkAttachmentReference2_pnext(struct vn_cs_encoder *enc, const void *val)
762{
763    const VkBaseInStructure *pnext = val;
764
765    while (pnext) {
766        switch ((int32_t)pnext->sType) {
767        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
768            vn_encode_simple_pointer(enc, pnext);
769            vn_encode_VkStructureType(enc, &pnext->sType);
770            vn_encode_VkAttachmentReference2_pnext(enc, pnext->pNext);
771            vn_encode_VkAttachmentReferenceStencilLayout_self(enc, (const VkAttachmentReferenceStencilLayout *)pnext);
772            return;
773        default:
774            /* ignore unknown/unsupported struct */
775            break;
776        }
777        pnext = pnext->pNext;
778    }
779
780    vn_encode_simple_pointer(enc, NULL);
781}
782
783static inline void
784vn_encode_VkAttachmentReference2_self(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
785{
786    /* skip val->{sType,pNext} */
787    vn_encode_uint32_t(enc, &val->attachment);
788    vn_encode_VkImageLayout(enc, &val->layout);
789    vn_encode_VkFlags(enc, &val->aspectMask);
790}
791
792static inline void
793vn_encode_VkAttachmentReference2(struct vn_cs_encoder *enc, const VkAttachmentReference2 *val)
794{
795    assert(val->sType == VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2);
796    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 });
797    vn_encode_VkAttachmentReference2_pnext(enc, val->pNext);
798    vn_encode_VkAttachmentReference2_self(enc, val);
799}
800
801/* struct VkSubpassDescriptionDepthStencilResolve chain */
802
803static inline size_t
804vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(const void *val)
805{
806    /* no known/supported struct */
807    return vn_sizeof_simple_pointer(NULL);
808}
809
810static inline size_t
811vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(const VkSubpassDescriptionDepthStencilResolve *val)
812{
813    size_t size = 0;
814    /* skip val->{sType,pNext} */
815    size += vn_sizeof_VkResolveModeFlagBits(&val->depthResolveMode);
816    size += vn_sizeof_VkResolveModeFlagBits(&val->stencilResolveMode);
817    size += vn_sizeof_simple_pointer(val->pDepthStencilResolveAttachment);
818    if (val->pDepthStencilResolveAttachment)
819        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilResolveAttachment);
820    return size;
821}
822
823static inline size_t
824vn_sizeof_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve *val)
825{
826    size_t size = 0;
827
828    size += vn_sizeof_VkStructureType(&val->sType);
829    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_pnext(val->pNext);
830    size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self(val);
831
832    return size;
833}
834
835static inline void
836vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(struct vn_cs_encoder *enc, const void *val)
837{
838    /* no known/supported struct */
839    vn_encode_simple_pointer(enc, NULL);
840}
841
842static inline void
843vn_encode_VkSubpassDescriptionDepthStencilResolve_self(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
844{
845    /* skip val->{sType,pNext} */
846    vn_encode_VkResolveModeFlagBits(enc, &val->depthResolveMode);
847    vn_encode_VkResolveModeFlagBits(enc, &val->stencilResolveMode);
848    if (vn_encode_simple_pointer(enc, val->pDepthStencilResolveAttachment))
849        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilResolveAttachment);
850}
851
852static inline void
853vn_encode_VkSubpassDescriptionDepthStencilResolve(struct vn_cs_encoder *enc, const VkSubpassDescriptionDepthStencilResolve *val)
854{
855    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);
856    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE });
857    vn_encode_VkSubpassDescriptionDepthStencilResolve_pnext(enc, val->pNext);
858    vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, val);
859}
860
861/* struct VkSubpassDescription2 chain */
862
863static inline size_t
864vn_sizeof_VkSubpassDescription2_pnext(const void *val)
865{
866    const VkBaseInStructure *pnext = val;
867    size_t size = 0;
868
869    while (pnext) {
870        switch ((int32_t)pnext->sType) {
871        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
872            size += vn_sizeof_simple_pointer(pnext);
873            size += vn_sizeof_VkStructureType(&pnext->sType);
874            size += vn_sizeof_VkSubpassDescription2_pnext(pnext->pNext);
875            size += vn_sizeof_VkSubpassDescriptionDepthStencilResolve_self((const VkSubpassDescriptionDepthStencilResolve *)pnext);
876            return size;
877        default:
878            /* ignore unknown/unsupported struct */
879            break;
880        }
881        pnext = pnext->pNext;
882    }
883
884    return vn_sizeof_simple_pointer(NULL);
885}
886
887static inline size_t
888vn_sizeof_VkSubpassDescription2_self(const VkSubpassDescription2 *val)
889{
890    size_t size = 0;
891    /* skip val->{sType,pNext} */
892    size += vn_sizeof_VkFlags(&val->flags);
893    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
894    size += vn_sizeof_uint32_t(&val->viewMask);
895    size += vn_sizeof_uint32_t(&val->inputAttachmentCount);
896    if (val->pInputAttachments) {
897        size += vn_sizeof_array_size(val->inputAttachmentCount);
898        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
899            size += vn_sizeof_VkAttachmentReference2(&val->pInputAttachments[i]);
900    } else {
901        size += vn_sizeof_array_size(0);
902    }
903    size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
904    if (val->pColorAttachments) {
905        size += vn_sizeof_array_size(val->colorAttachmentCount);
906        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
907            size += vn_sizeof_VkAttachmentReference2(&val->pColorAttachments[i]);
908    } else {
909        size += vn_sizeof_array_size(0);
910    }
911    if (val->pResolveAttachments) {
912        size += vn_sizeof_array_size(val->colorAttachmentCount);
913        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
914            size += vn_sizeof_VkAttachmentReference2(&val->pResolveAttachments[i]);
915    } else {
916        size += vn_sizeof_array_size(0);
917    }
918    size += vn_sizeof_simple_pointer(val->pDepthStencilAttachment);
919    if (val->pDepthStencilAttachment)
920        size += vn_sizeof_VkAttachmentReference2(val->pDepthStencilAttachment);
921    size += vn_sizeof_uint32_t(&val->preserveAttachmentCount);
922    if (val->pPreserveAttachments) {
923        size += vn_sizeof_array_size(val->preserveAttachmentCount);
924        size += vn_sizeof_uint32_t_array(val->pPreserveAttachments, val->preserveAttachmentCount);
925    } else {
926        size += vn_sizeof_array_size(0);
927    }
928    return size;
929}
930
931static inline size_t
932vn_sizeof_VkSubpassDescription2(const VkSubpassDescription2 *val)
933{
934    size_t size = 0;
935
936    size += vn_sizeof_VkStructureType(&val->sType);
937    size += vn_sizeof_VkSubpassDescription2_pnext(val->pNext);
938    size += vn_sizeof_VkSubpassDescription2_self(val);
939
940    return size;
941}
942
943static inline void
944vn_encode_VkSubpassDescription2_pnext(struct vn_cs_encoder *enc, const void *val)
945{
946    const VkBaseInStructure *pnext = val;
947
948    while (pnext) {
949        switch ((int32_t)pnext->sType) {
950        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
951            vn_encode_simple_pointer(enc, pnext);
952            vn_encode_VkStructureType(enc, &pnext->sType);
953            vn_encode_VkSubpassDescription2_pnext(enc, pnext->pNext);
954            vn_encode_VkSubpassDescriptionDepthStencilResolve_self(enc, (const VkSubpassDescriptionDepthStencilResolve *)pnext);
955            return;
956        default:
957            /* ignore unknown/unsupported struct */
958            break;
959        }
960        pnext = pnext->pNext;
961    }
962
963    vn_encode_simple_pointer(enc, NULL);
964}
965
966static inline void
967vn_encode_VkSubpassDescription2_self(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
968{
969    /* skip val->{sType,pNext} */
970    vn_encode_VkFlags(enc, &val->flags);
971    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
972    vn_encode_uint32_t(enc, &val->viewMask);
973    vn_encode_uint32_t(enc, &val->inputAttachmentCount);
974    if (val->pInputAttachments) {
975        vn_encode_array_size(enc, val->inputAttachmentCount);
976        for (uint32_t i = 0; i < val->inputAttachmentCount; i++)
977            vn_encode_VkAttachmentReference2(enc, &val->pInputAttachments[i]);
978    } else {
979        vn_encode_array_size(enc, 0);
980    }
981    vn_encode_uint32_t(enc, &val->colorAttachmentCount);
982    if (val->pColorAttachments) {
983        vn_encode_array_size(enc, val->colorAttachmentCount);
984        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
985            vn_encode_VkAttachmentReference2(enc, &val->pColorAttachments[i]);
986    } else {
987        vn_encode_array_size(enc, 0);
988    }
989    if (val->pResolveAttachments) {
990        vn_encode_array_size(enc, val->colorAttachmentCount);
991        for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
992            vn_encode_VkAttachmentReference2(enc, &val->pResolveAttachments[i]);
993    } else {
994        vn_encode_array_size(enc, 0);
995    }
996    if (vn_encode_simple_pointer(enc, val->pDepthStencilAttachment))
997        vn_encode_VkAttachmentReference2(enc, val->pDepthStencilAttachment);
998    vn_encode_uint32_t(enc, &val->preserveAttachmentCount);
999    if (val->pPreserveAttachments) {
1000        vn_encode_array_size(enc, val->preserveAttachmentCount);
1001        vn_encode_uint32_t_array(enc, val->pPreserveAttachments, val->preserveAttachmentCount);
1002    } else {
1003        vn_encode_array_size(enc, 0);
1004    }
1005}
1006
1007static inline void
1008vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescription2 *val)
1009{
1010    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2);
1011    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 });
1012    vn_encode_VkSubpassDescription2_pnext(enc, val->pNext);
1013    vn_encode_VkSubpassDescription2_self(enc, val);
1014}
1015
1016/* struct VkSubpassDependency2 chain */
1017
1018static inline size_t
1019vn_sizeof_VkSubpassDependency2_pnext(const void *val)
1020{
1021    /* no known/supported struct */
1022    return vn_sizeof_simple_pointer(NULL);
1023}
1024
1025static inline size_t
1026vn_sizeof_VkSubpassDependency2_self(const VkSubpassDependency2 *val)
1027{
1028    size_t size = 0;
1029    /* skip val->{sType,pNext} */
1030    size += vn_sizeof_uint32_t(&val->srcSubpass);
1031    size += vn_sizeof_uint32_t(&val->dstSubpass);
1032    size += vn_sizeof_VkFlags(&val->srcStageMask);
1033    size += vn_sizeof_VkFlags(&val->dstStageMask);
1034    size += vn_sizeof_VkFlags(&val->srcAccessMask);
1035    size += vn_sizeof_VkFlags(&val->dstAccessMask);
1036    size += vn_sizeof_VkFlags(&val->dependencyFlags);
1037    size += vn_sizeof_int32_t(&val->viewOffset);
1038    return size;
1039}
1040
1041static inline size_t
1042vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val)
1043{
1044    size_t size = 0;
1045
1046    size += vn_sizeof_VkStructureType(&val->sType);
1047    size += vn_sizeof_VkSubpassDependency2_pnext(val->pNext);
1048    size += vn_sizeof_VkSubpassDependency2_self(val);
1049
1050    return size;
1051}
1052
1053static inline void
1054vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val)
1055{
1056    /* no known/supported struct */
1057    vn_encode_simple_pointer(enc, NULL);
1058}
1059
1060static inline void
1061vn_encode_VkSubpassDependency2_self(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
1062{
1063    /* skip val->{sType,pNext} */
1064    vn_encode_uint32_t(enc, &val->srcSubpass);
1065    vn_encode_uint32_t(enc, &val->dstSubpass);
1066    vn_encode_VkFlags(enc, &val->srcStageMask);
1067    vn_encode_VkFlags(enc, &val->dstStageMask);
1068    vn_encode_VkFlags(enc, &val->srcAccessMask);
1069    vn_encode_VkFlags(enc, &val->dstAccessMask);
1070    vn_encode_VkFlags(enc, &val->dependencyFlags);
1071    vn_encode_int32_t(enc, &val->viewOffset);
1072}
1073
1074static inline void
1075vn_encode_VkSubpassDependency2(struct vn_cs_encoder *enc, const VkSubpassDependency2 *val)
1076{
1077    assert(val->sType == VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2);
1078    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 });
1079    vn_encode_VkSubpassDependency2_pnext(enc, val->pNext);
1080    vn_encode_VkSubpassDependency2_self(enc, val);
1081}
1082
1083/* struct VkRenderPassCreateInfo2 chain */
1084
1085static inline size_t
1086vn_sizeof_VkRenderPassCreateInfo2_pnext(const void *val)
1087{
1088    /* no known/supported struct */
1089    return vn_sizeof_simple_pointer(NULL);
1090}
1091
1092static inline size_t
1093vn_sizeof_VkRenderPassCreateInfo2_self(const VkRenderPassCreateInfo2 *val)
1094{
1095    size_t size = 0;
1096    /* skip val->{sType,pNext} */
1097    size += vn_sizeof_VkFlags(&val->flags);
1098    size += vn_sizeof_uint32_t(&val->attachmentCount);
1099    if (val->pAttachments) {
1100        size += vn_sizeof_array_size(val->attachmentCount);
1101        for (uint32_t i = 0; i < val->attachmentCount; i++)
1102            size += vn_sizeof_VkAttachmentDescription2(&val->pAttachments[i]);
1103    } else {
1104        size += vn_sizeof_array_size(0);
1105    }
1106    size += vn_sizeof_uint32_t(&val->subpassCount);
1107    if (val->pSubpasses) {
1108        size += vn_sizeof_array_size(val->subpassCount);
1109        for (uint32_t i = 0; i < val->subpassCount; i++)
1110            size += vn_sizeof_VkSubpassDescription2(&val->pSubpasses[i]);
1111    } else {
1112        size += vn_sizeof_array_size(0);
1113    }
1114    size += vn_sizeof_uint32_t(&val->dependencyCount);
1115    if (val->pDependencies) {
1116        size += vn_sizeof_array_size(val->dependencyCount);
1117        for (uint32_t i = 0; i < val->dependencyCount; i++)
1118            size += vn_sizeof_VkSubpassDependency2(&val->pDependencies[i]);
1119    } else {
1120        size += vn_sizeof_array_size(0);
1121    }
1122    size += vn_sizeof_uint32_t(&val->correlatedViewMaskCount);
1123    if (val->pCorrelatedViewMasks) {
1124        size += vn_sizeof_array_size(val->correlatedViewMaskCount);
1125        size += vn_sizeof_uint32_t_array(val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
1126    } else {
1127        size += vn_sizeof_array_size(0);
1128    }
1129    return size;
1130}
1131
1132static inline size_t
1133vn_sizeof_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2 *val)
1134{
1135    size_t size = 0;
1136
1137    size += vn_sizeof_VkStructureType(&val->sType);
1138    size += vn_sizeof_VkRenderPassCreateInfo2_pnext(val->pNext);
1139    size += vn_sizeof_VkRenderPassCreateInfo2_self(val);
1140
1141    return size;
1142}
1143
1144static inline void
1145vn_encode_VkRenderPassCreateInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
1146{
1147    /* no known/supported struct */
1148    vn_encode_simple_pointer(enc, NULL);
1149}
1150
1151static inline void
1152vn_encode_VkRenderPassCreateInfo2_self(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
1153{
1154    /* skip val->{sType,pNext} */
1155    vn_encode_VkFlags(enc, &val->flags);
1156    vn_encode_uint32_t(enc, &val->attachmentCount);
1157    if (val->pAttachments) {
1158        vn_encode_array_size(enc, val->attachmentCount);
1159        for (uint32_t i = 0; i < val->attachmentCount; i++)
1160            vn_encode_VkAttachmentDescription2(enc, &val->pAttachments[i]);
1161    } else {
1162        vn_encode_array_size(enc, 0);
1163    }
1164    vn_encode_uint32_t(enc, &val->subpassCount);
1165    if (val->pSubpasses) {
1166        vn_encode_array_size(enc, val->subpassCount);
1167        for (uint32_t i = 0; i < val->subpassCount; i++)
1168            vn_encode_VkSubpassDescription2(enc, &val->pSubpasses[i]);
1169    } else {
1170        vn_encode_array_size(enc, 0);
1171    }
1172    vn_encode_uint32_t(enc, &val->dependencyCount);
1173    if (val->pDependencies) {
1174        vn_encode_array_size(enc, val->dependencyCount);
1175        for (uint32_t i = 0; i < val->dependencyCount; i++)
1176            vn_encode_VkSubpassDependency2(enc, &val->pDependencies[i]);
1177    } else {
1178        vn_encode_array_size(enc, 0);
1179    }
1180    vn_encode_uint32_t(enc, &val->correlatedViewMaskCount);
1181    if (val->pCorrelatedViewMasks) {
1182        vn_encode_array_size(enc, val->correlatedViewMaskCount);
1183        vn_encode_uint32_t_array(enc, val->pCorrelatedViewMasks, val->correlatedViewMaskCount);
1184    } else {
1185        vn_encode_array_size(enc, 0);
1186    }
1187}
1188
1189static inline void
1190vn_encode_VkRenderPassCreateInfo2(struct vn_cs_encoder *enc, const VkRenderPassCreateInfo2 *val)
1191{
1192    assert(val->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2);
1193    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 });
1194    vn_encode_VkRenderPassCreateInfo2_pnext(enc, val->pNext);
1195    vn_encode_VkRenderPassCreateInfo2_self(enc, val);
1196}
1197
1198static inline size_t vn_sizeof_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1199{
1200    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
1201    const VkFlags cmd_flags = 0;
1202    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1203
1204    cmd_size += vn_sizeof_VkDevice(&device);
1205    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
1206    if (pCreateInfo)
1207        cmd_size += vn_sizeof_VkRenderPassCreateInfo(pCreateInfo);
1208    cmd_size += vn_sizeof_simple_pointer(pAllocator);
1209    if (pAllocator)
1210        assert(false);
1211    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1212    if (pRenderPass)
1213        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1214
1215    return cmd_size;
1216}
1217
1218static inline void vn_encode_vkCreateRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1219{
1220    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
1221
1222    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1223    vn_encode_VkFlags(enc, &cmd_flags);
1224
1225    vn_encode_VkDevice(enc, &device);
1226    if (vn_encode_simple_pointer(enc, pCreateInfo))
1227        vn_encode_VkRenderPassCreateInfo(enc, pCreateInfo);
1228    if (vn_encode_simple_pointer(enc, pAllocator))
1229        assert(false);
1230    if (vn_encode_simple_pointer(enc, pRenderPass))
1231        vn_encode_VkRenderPass(enc, pRenderPass);
1232}
1233
1234static inline size_t vn_sizeof_vkCreateRenderPass_reply(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1235{
1236    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass_EXT;
1237    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1238
1239    VkResult ret;
1240    cmd_size += vn_sizeof_VkResult(&ret);
1241    /* skip device */
1242    /* skip pCreateInfo */
1243    /* skip pAllocator */
1244    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1245    if (pRenderPass)
1246        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1247
1248    return cmd_size;
1249}
1250
1251static inline VkResult vn_decode_vkCreateRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1252{
1253    VkCommandTypeEXT command_type;
1254    vn_decode_VkCommandTypeEXT(dec, &command_type);
1255    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass_EXT);
1256
1257    VkResult ret;
1258    vn_decode_VkResult(dec, &ret);
1259    /* skip device */
1260    /* skip pCreateInfo */
1261    /* skip pAllocator */
1262    if (vn_decode_simple_pointer(dec)) {
1263        vn_decode_VkRenderPass(dec, pRenderPass);
1264    } else {
1265        pRenderPass = NULL;
1266    }
1267
1268    return ret;
1269}
1270
1271static inline size_t vn_sizeof_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1272{
1273    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
1274    const VkFlags cmd_flags = 0;
1275    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1276
1277    cmd_size += vn_sizeof_VkDevice(&device);
1278    cmd_size += vn_sizeof_VkRenderPass(&renderPass);
1279    cmd_size += vn_sizeof_simple_pointer(pAllocator);
1280    if (pAllocator)
1281        assert(false);
1282
1283    return cmd_size;
1284}
1285
1286static inline void vn_encode_vkDestroyRenderPass(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1287{
1288    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
1289
1290    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1291    vn_encode_VkFlags(enc, &cmd_flags);
1292
1293    vn_encode_VkDevice(enc, &device);
1294    vn_encode_VkRenderPass(enc, &renderPass);
1295    if (vn_encode_simple_pointer(enc, pAllocator))
1296        assert(false);
1297}
1298
1299static inline size_t vn_sizeof_vkDestroyRenderPass_reply(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1300{
1301    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRenderPass_EXT;
1302    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1303
1304    /* skip device */
1305    /* skip renderPass */
1306    /* skip pAllocator */
1307
1308    return cmd_size;
1309}
1310
1311static inline void vn_decode_vkDestroyRenderPass_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1312{
1313    VkCommandTypeEXT command_type;
1314    vn_decode_VkCommandTypeEXT(dec, &command_type);
1315    assert(command_type == VK_COMMAND_TYPE_vkDestroyRenderPass_EXT);
1316
1317    /* skip device */
1318    /* skip renderPass */
1319    /* skip pAllocator */
1320}
1321
1322static inline size_t vn_sizeof_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1323{
1324    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
1325    const VkFlags cmd_flags = 0;
1326    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1327
1328    cmd_size += vn_sizeof_VkDevice(&device);
1329    cmd_size += vn_sizeof_VkRenderPass(&renderPass);
1330    cmd_size += vn_sizeof_simple_pointer(pGranularity);
1331    if (pGranularity)
1332        cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity);
1333
1334    return cmd_size;
1335}
1336
1337static inline void vn_encode_vkGetRenderAreaGranularity(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1338{
1339    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
1340
1341    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1342    vn_encode_VkFlags(enc, &cmd_flags);
1343
1344    vn_encode_VkDevice(enc, &device);
1345    vn_encode_VkRenderPass(enc, &renderPass);
1346    if (vn_encode_simple_pointer(enc, pGranularity))
1347        vn_encode_VkExtent2D_partial(enc, pGranularity);
1348}
1349
1350static inline size_t vn_sizeof_vkGetRenderAreaGranularity_reply(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1351{
1352    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT;
1353    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1354
1355    /* skip device */
1356    /* skip renderPass */
1357    cmd_size += vn_sizeof_simple_pointer(pGranularity);
1358    if (pGranularity)
1359        cmd_size += vn_sizeof_VkExtent2D(pGranularity);
1360
1361    return cmd_size;
1362}
1363
1364static inline void vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decoder *dec, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1365{
1366    VkCommandTypeEXT command_type;
1367    vn_decode_VkCommandTypeEXT(dec, &command_type);
1368    assert(command_type == VK_COMMAND_TYPE_vkGetRenderAreaGranularity_EXT);
1369
1370    /* skip device */
1371    /* skip renderPass */
1372    if (vn_decode_simple_pointer(dec)) {
1373        vn_decode_VkExtent2D(dec, pGranularity);
1374    } else {
1375        pGranularity = NULL;
1376    }
1377}
1378
1379static inline size_t vn_sizeof_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1380{
1381    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
1382    const VkFlags cmd_flags = 0;
1383    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1384
1385    cmd_size += vn_sizeof_VkDevice(&device);
1386    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
1387    if (pCreateInfo)
1388        cmd_size += vn_sizeof_VkRenderPassCreateInfo2(pCreateInfo);
1389    cmd_size += vn_sizeof_simple_pointer(pAllocator);
1390    if (pAllocator)
1391        assert(false);
1392    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1393    if (pRenderPass)
1394        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1395
1396    return cmd_size;
1397}
1398
1399static inline void vn_encode_vkCreateRenderPass2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1400{
1401    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
1402
1403    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1404    vn_encode_VkFlags(enc, &cmd_flags);
1405
1406    vn_encode_VkDevice(enc, &device);
1407    if (vn_encode_simple_pointer(enc, pCreateInfo))
1408        vn_encode_VkRenderPassCreateInfo2(enc, pCreateInfo);
1409    if (vn_encode_simple_pointer(enc, pAllocator))
1410        assert(false);
1411    if (vn_encode_simple_pointer(enc, pRenderPass))
1412        vn_encode_VkRenderPass(enc, pRenderPass);
1413}
1414
1415static inline size_t vn_sizeof_vkCreateRenderPass2_reply(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1416{
1417    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
1418    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1419
1420    VkResult ret;
1421    cmd_size += vn_sizeof_VkResult(&ret);
1422    /* skip device */
1423    /* skip pCreateInfo */
1424    /* skip pAllocator */
1425    cmd_size += vn_sizeof_simple_pointer(pRenderPass);
1426    if (pRenderPass)
1427        cmd_size += vn_sizeof_VkRenderPass(pRenderPass);
1428
1429    return cmd_size;
1430}
1431
1432static inline VkResult vn_decode_vkCreateRenderPass2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1433{
1434    VkCommandTypeEXT command_type;
1435    vn_decode_VkCommandTypeEXT(dec, &command_type);
1436    assert(command_type == VK_COMMAND_TYPE_vkCreateRenderPass2_EXT);
1437
1438    VkResult ret;
1439    vn_decode_VkResult(dec, &ret);
1440    /* skip device */
1441    /* skip pCreateInfo */
1442    /* skip pAllocator */
1443    if (vn_decode_simple_pointer(dec)) {
1444        vn_decode_VkRenderPass(dec, pRenderPass);
1445    } else {
1446        pRenderPass = NULL;
1447    }
1448
1449    return ret;
1450}
1451
1452static inline void vn_submit_vkCreateRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)
1453{
1454    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1455    void *cmd_data = local_cmd_data;
1456    size_t cmd_size = vn_sizeof_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
1457    if (cmd_size > sizeof(local_cmd_data)) {
1458        cmd_data = malloc(cmd_size);
1459        if (!cmd_data)
1460            cmd_size = 0;
1461    }
1462    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
1463
1464    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1465    if (cmd_size) {
1466        vn_encode_vkCreateRenderPass(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
1467        vn_instance_submit_command(vn_instance, submit);
1468        if (cmd_data != local_cmd_data)
1469            free(cmd_data);
1470    }
1471}
1472
1473static inline void vn_submit_vkDestroyRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
1474{
1475    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1476    void *cmd_data = local_cmd_data;
1477    size_t cmd_size = vn_sizeof_vkDestroyRenderPass(device, renderPass, pAllocator);
1478    if (cmd_size > sizeof(local_cmd_data)) {
1479        cmd_data = malloc(cmd_size);
1480        if (!cmd_data)
1481            cmd_size = 0;
1482    }
1483    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0;
1484
1485    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1486    if (cmd_size) {
1487        vn_encode_vkDestroyRenderPass(enc, cmd_flags, device, renderPass, pAllocator);
1488        vn_instance_submit_command(vn_instance, submit);
1489        if (cmd_data != local_cmd_data)
1490            free(cmd_data);
1491    }
1492}
1493
1494static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, struct vn_instance_submit_command *submit)
1495{
1496    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1497    void *cmd_data = local_cmd_data;
1498    size_t cmd_size = vn_sizeof_vkGetRenderAreaGranularity(device, renderPass, pGranularity);
1499    if (cmd_size > sizeof(local_cmd_data)) {
1500        cmd_data = malloc(cmd_size);
1501        if (!cmd_data)
1502            cmd_size = 0;
1503    }
1504    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0;
1505
1506    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1507    if (cmd_size) {
1508        vn_encode_vkGetRenderAreaGranularity(enc, cmd_flags, device, renderPass, pGranularity);
1509        vn_instance_submit_command(vn_instance, submit);
1510        if (cmd_data != local_cmd_data)
1511            free(cmd_data);
1512    }
1513}
1514
1515static inline void vn_submit_vkCreateRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)
1516{
1517    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
1518    void *cmd_data = local_cmd_data;
1519    size_t cmd_size = vn_sizeof_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
1520    if (cmd_size > sizeof(local_cmd_data)) {
1521        cmd_data = malloc(cmd_size);
1522        if (!cmd_data)
1523            cmd_size = 0;
1524    }
1525    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
1526
1527    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
1528    if (cmd_size) {
1529        vn_encode_vkCreateRenderPass2(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
1530        vn_instance_submit_command(vn_instance, submit);
1531        if (cmd_data != local_cmd_data)
1532            free(cmd_data);
1533    }
1534}
1535
1536static inline VkResult vn_call_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1537{
1538    VN_TRACE_FUNC();
1539
1540    struct vn_instance_submit_command submit;
1541    vn_submit_vkCreateRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1542    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1543    if (dec) {
1544        const VkResult ret = vn_decode_vkCreateRenderPass_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);
1545        vn_instance_free_command_reply(vn_instance, &submit);
1546        return ret;
1547    } else {
1548        return VK_ERROR_OUT_OF_HOST_MEMORY;
1549    }
1550}
1551
1552static inline void vn_async_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1553{
1554    struct vn_instance_submit_command submit;
1555    vn_submit_vkCreateRenderPass(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1556}
1557
1558static inline void vn_call_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1559{
1560    VN_TRACE_FUNC();
1561
1562    struct vn_instance_submit_command submit;
1563    vn_submit_vkDestroyRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pAllocator, &submit);
1564    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1565    if (dec) {
1566        vn_decode_vkDestroyRenderPass_reply(dec, device, renderPass, pAllocator);
1567        vn_instance_free_command_reply(vn_instance, &submit);
1568    }
1569}
1570
1571static inline void vn_async_vkDestroyRenderPass(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
1572{
1573    struct vn_instance_submit_command submit;
1574    vn_submit_vkDestroyRenderPass(vn_instance, 0, device, renderPass, pAllocator, &submit);
1575}
1576
1577static inline void vn_call_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1578{
1579    VN_TRACE_FUNC();
1580
1581    struct vn_instance_submit_command submit;
1582    vn_submit_vkGetRenderAreaGranularity(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pGranularity, &submit);
1583    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1584    if (dec) {
1585        vn_decode_vkGetRenderAreaGranularity_reply(dec, device, renderPass, pGranularity);
1586        vn_instance_free_command_reply(vn_instance, &submit);
1587    }
1588}
1589
1590static inline void vn_async_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1591{
1592    struct vn_instance_submit_command submit;
1593    vn_submit_vkGetRenderAreaGranularity(vn_instance, 0, device, renderPass, pGranularity, &submit);
1594}
1595
1596static inline VkResult vn_call_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1597{
1598    VN_TRACE_FUNC();
1599
1600    struct vn_instance_submit_command submit;
1601    vn_submit_vkCreateRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1602    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
1603    if (dec) {
1604        const VkResult ret = vn_decode_vkCreateRenderPass2_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);
1605        vn_instance_free_command_reply(vn_instance, &submit);
1606        return ret;
1607    } else {
1608        return VK_ERROR_OUT_OF_HOST_MEMORY;
1609    }
1610}
1611
1612static inline void vn_async_vkCreateRenderPass2(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
1613{
1614    struct vn_instance_submit_command submit;
1615    vn_submit_vkCreateRenderPass2(vn_instance, 0, device, pCreateInfo, pAllocator, pRenderPass, &submit);
1616}
1617
1618#endif /* VN_PROTOCOL_DRIVER_RENDER_PASS_H */
1619