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_IMAGE_H
9#define VN_PROTOCOL_DRIVER_IMAGE_H
10
11#include "vn_instance.h"
12#include "vn_protocol_driver_structs.h"
13
14/* struct VkSparseImageMemoryRequirements */
15
16static inline size_t
17vn_sizeof_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements *val)
18{
19    size_t size = 0;
20    size += vn_sizeof_VkSparseImageFormatProperties(&val->formatProperties);
21    size += vn_sizeof_uint32_t(&val->imageMipTailFirstLod);
22    size += vn_sizeof_VkDeviceSize(&val->imageMipTailSize);
23    size += vn_sizeof_VkDeviceSize(&val->imageMipTailOffset);
24    size += vn_sizeof_VkDeviceSize(&val->imageMipTailStride);
25    return size;
26}
27
28static inline void
29vn_decode_VkSparseImageMemoryRequirements(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements *val)
30{
31    vn_decode_VkSparseImageFormatProperties(dec, &val->formatProperties);
32    vn_decode_uint32_t(dec, &val->imageMipTailFirstLod);
33    vn_decode_VkDeviceSize(dec, &val->imageMipTailSize);
34    vn_decode_VkDeviceSize(dec, &val->imageMipTailOffset);
35    vn_decode_VkDeviceSize(dec, &val->imageMipTailStride);
36}
37
38static inline size_t
39vn_sizeof_VkSparseImageMemoryRequirements_partial(const VkSparseImageMemoryRequirements *val)
40{
41    size_t size = 0;
42    size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->formatProperties);
43    /* skip val->imageMipTailFirstLod */
44    /* skip val->imageMipTailSize */
45    /* skip val->imageMipTailOffset */
46    /* skip val->imageMipTailStride */
47    return size;
48}
49
50static inline void
51vn_encode_VkSparseImageMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements *val)
52{
53    vn_encode_VkSparseImageFormatProperties_partial(enc, &val->formatProperties);
54    /* skip val->imageMipTailFirstLod */
55    /* skip val->imageMipTailSize */
56    /* skip val->imageMipTailOffset */
57    /* skip val->imageMipTailStride */
58}
59
60/* struct VkExternalMemoryImageCreateInfo chain */
61
62static inline size_t
63vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(const void *val)
64{
65    /* no known/supported struct */
66    return vn_sizeof_simple_pointer(NULL);
67}
68
69static inline size_t
70vn_sizeof_VkExternalMemoryImageCreateInfo_self(const VkExternalMemoryImageCreateInfo *val)
71{
72    size_t size = 0;
73    /* skip val->{sType,pNext} */
74    size += vn_sizeof_VkFlags(&val->handleTypes);
75    return size;
76}
77
78static inline size_t
79vn_sizeof_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo *val)
80{
81    size_t size = 0;
82
83    size += vn_sizeof_VkStructureType(&val->sType);
84    size += vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(val->pNext);
85    size += vn_sizeof_VkExternalMemoryImageCreateInfo_self(val);
86
87    return size;
88}
89
90static inline void
91vn_encode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
92{
93    /* no known/supported struct */
94    vn_encode_simple_pointer(enc, NULL);
95}
96
97static inline void
98vn_encode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
99{
100    /* skip val->{sType,pNext} */
101    vn_encode_VkFlags(enc, &val->handleTypes);
102}
103
104static inline void
105vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
106{
107    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
108    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO });
109    vn_encode_VkExternalMemoryImageCreateInfo_pnext(enc, val->pNext);
110    vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val);
111}
112
113/* struct VkImageDrmFormatModifierListCreateInfoEXT chain */
114
115static inline size_t
116vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(const void *val)
117{
118    /* no known/supported struct */
119    return vn_sizeof_simple_pointer(NULL);
120}
121
122static inline size_t
123vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(const VkImageDrmFormatModifierListCreateInfoEXT *val)
124{
125    size_t size = 0;
126    /* skip val->{sType,pNext} */
127    size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
128    if (val->pDrmFormatModifiers) {
129        size += vn_sizeof_array_size(val->drmFormatModifierCount);
130        size += vn_sizeof_uint64_t_array(val->pDrmFormatModifiers, val->drmFormatModifierCount);
131    } else {
132        size += vn_sizeof_array_size(0);
133    }
134    return size;
135}
136
137static inline size_t
138vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT *val)
139{
140    size_t size = 0;
141
142    size += vn_sizeof_VkStructureType(&val->sType);
143    size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(val->pNext);
144    size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(val);
145
146    return size;
147}
148
149static inline void
150vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
151{
152    /* no known/supported struct */
153    vn_encode_simple_pointer(enc, NULL);
154}
155
156static inline void
157vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
158{
159    /* skip val->{sType,pNext} */
160    vn_encode_uint32_t(enc, &val->drmFormatModifierCount);
161    if (val->pDrmFormatModifiers) {
162        vn_encode_array_size(enc, val->drmFormatModifierCount);
163        vn_encode_uint64_t_array(enc, val->pDrmFormatModifiers, val->drmFormatModifierCount);
164    } else {
165        vn_encode_array_size(enc, 0);
166    }
167}
168
169static inline void
170vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
171{
172    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
173    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT });
174    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(enc, val->pNext);
175    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val);
176}
177
178/* struct VkSubresourceLayout */
179
180static inline size_t
181vn_sizeof_VkSubresourceLayout(const VkSubresourceLayout *val)
182{
183    size_t size = 0;
184    size += vn_sizeof_VkDeviceSize(&val->offset);
185    size += vn_sizeof_VkDeviceSize(&val->size);
186    size += vn_sizeof_VkDeviceSize(&val->rowPitch);
187    size += vn_sizeof_VkDeviceSize(&val->arrayPitch);
188    size += vn_sizeof_VkDeviceSize(&val->depthPitch);
189    return size;
190}
191
192static inline void
193vn_encode_VkSubresourceLayout(struct vn_cs_encoder *enc, const VkSubresourceLayout *val)
194{
195    vn_encode_VkDeviceSize(enc, &val->offset);
196    vn_encode_VkDeviceSize(enc, &val->size);
197    vn_encode_VkDeviceSize(enc, &val->rowPitch);
198    vn_encode_VkDeviceSize(enc, &val->arrayPitch);
199    vn_encode_VkDeviceSize(enc, &val->depthPitch);
200}
201
202static inline void
203vn_decode_VkSubresourceLayout(struct vn_cs_decoder *dec, VkSubresourceLayout *val)
204{
205    vn_decode_VkDeviceSize(dec, &val->offset);
206    vn_decode_VkDeviceSize(dec, &val->size);
207    vn_decode_VkDeviceSize(dec, &val->rowPitch);
208    vn_decode_VkDeviceSize(dec, &val->arrayPitch);
209    vn_decode_VkDeviceSize(dec, &val->depthPitch);
210}
211
212static inline size_t
213vn_sizeof_VkSubresourceLayout_partial(const VkSubresourceLayout *val)
214{
215    size_t size = 0;
216    /* skip val->offset */
217    /* skip val->size */
218    /* skip val->rowPitch */
219    /* skip val->arrayPitch */
220    /* skip val->depthPitch */
221    return size;
222}
223
224static inline void
225vn_encode_VkSubresourceLayout_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout *val)
226{
227    /* skip val->offset */
228    /* skip val->size */
229    /* skip val->rowPitch */
230    /* skip val->arrayPitch */
231    /* skip val->depthPitch */
232}
233
234/* struct VkImageDrmFormatModifierExplicitCreateInfoEXT chain */
235
236static inline size_t
237vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(const void *val)
238{
239    /* no known/supported struct */
240    return vn_sizeof_simple_pointer(NULL);
241}
242
243static inline size_t
244vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
245{
246    size_t size = 0;
247    /* skip val->{sType,pNext} */
248    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
249    size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
250    if (val->pPlaneLayouts) {
251        size += vn_sizeof_array_size(val->drmFormatModifierPlaneCount);
252        for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
253            size += vn_sizeof_VkSubresourceLayout(&val->pPlaneLayouts[i]);
254    } else {
255        size += vn_sizeof_array_size(0);
256    }
257    return size;
258}
259
260static inline size_t
261vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
262{
263    size_t size = 0;
264
265    size += vn_sizeof_VkStructureType(&val->sType);
266    size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(val->pNext);
267    size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(val);
268
269    return size;
270}
271
272static inline void
273vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
274{
275    /* no known/supported struct */
276    vn_encode_simple_pointer(enc, NULL);
277}
278
279static inline void
280vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
281{
282    /* skip val->{sType,pNext} */
283    vn_encode_uint64_t(enc, &val->drmFormatModifier);
284    vn_encode_uint32_t(enc, &val->drmFormatModifierPlaneCount);
285    if (val->pPlaneLayouts) {
286        vn_encode_array_size(enc, val->drmFormatModifierPlaneCount);
287        for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
288            vn_encode_VkSubresourceLayout(enc, &val->pPlaneLayouts[i]);
289    } else {
290        vn_encode_array_size(enc, 0);
291    }
292}
293
294static inline void
295vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
296{
297    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT);
298    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT });
299    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(enc, val->pNext);
300    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val);
301}
302
303/* struct VkImageCreateInfo chain */
304
305static inline size_t
306vn_sizeof_VkImageCreateInfo_pnext(const void *val)
307{
308    const VkBaseInStructure *pnext = val;
309    size_t size = 0;
310
311    while (pnext) {
312        switch ((int32_t)pnext->sType) {
313        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
314            size += vn_sizeof_simple_pointer(pnext);
315            size += vn_sizeof_VkStructureType(&pnext->sType);
316            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
317            size += vn_sizeof_VkExternalMemoryImageCreateInfo_self((const VkExternalMemoryImageCreateInfo *)pnext);
318            return size;
319        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
320            size += vn_sizeof_simple_pointer(pnext);
321            size += vn_sizeof_VkStructureType(&pnext->sType);
322            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
323            size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
324            return size;
325        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
326            if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
327                break;
328            size += vn_sizeof_simple_pointer(pnext);
329            size += vn_sizeof_VkStructureType(&pnext->sType);
330            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
331            size += vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self((const VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
332            return size;
333        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
334            if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
335                break;
336            size += vn_sizeof_simple_pointer(pnext);
337            size += vn_sizeof_VkStructureType(&pnext->sType);
338            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
339            size += vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self((const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
340            return size;
341        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
342            size += vn_sizeof_simple_pointer(pnext);
343            size += vn_sizeof_VkStructureType(&pnext->sType);
344            size += vn_sizeof_VkImageCreateInfo_pnext(pnext->pNext);
345            size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
346            return size;
347        default:
348            /* ignore unknown/unsupported struct */
349            break;
350        }
351        pnext = pnext->pNext;
352    }
353
354    return vn_sizeof_simple_pointer(NULL);
355}
356
357static inline size_t
358vn_sizeof_VkImageCreateInfo_self(const VkImageCreateInfo *val)
359{
360    size_t size = 0;
361    /* skip val->{sType,pNext} */
362    size += vn_sizeof_VkFlags(&val->flags);
363    size += vn_sizeof_VkImageType(&val->imageType);
364    size += vn_sizeof_VkFormat(&val->format);
365    size += vn_sizeof_VkExtent3D(&val->extent);
366    size += vn_sizeof_uint32_t(&val->mipLevels);
367    size += vn_sizeof_uint32_t(&val->arrayLayers);
368    size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
369    size += vn_sizeof_VkImageTiling(&val->tiling);
370    size += vn_sizeof_VkFlags(&val->usage);
371    size += vn_sizeof_VkSharingMode(&val->sharingMode);
372    size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
373    if (val->pQueueFamilyIndices) {
374        size += vn_sizeof_array_size(val->queueFamilyIndexCount);
375        size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
376    } else {
377        size += vn_sizeof_array_size(0);
378    }
379    size += vn_sizeof_VkImageLayout(&val->initialLayout);
380    return size;
381}
382
383static inline size_t
384vn_sizeof_VkImageCreateInfo(const VkImageCreateInfo *val)
385{
386    size_t size = 0;
387
388    size += vn_sizeof_VkStructureType(&val->sType);
389    size += vn_sizeof_VkImageCreateInfo_pnext(val->pNext);
390    size += vn_sizeof_VkImageCreateInfo_self(val);
391
392    return size;
393}
394
395static inline void
396vn_encode_VkImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
397{
398    const VkBaseInStructure *pnext = val;
399
400    while (pnext) {
401        switch ((int32_t)pnext->sType) {
402        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
403            vn_encode_simple_pointer(enc, pnext);
404            vn_encode_VkStructureType(enc, &pnext->sType);
405            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
406            vn_encode_VkExternalMemoryImageCreateInfo_self(enc, (const VkExternalMemoryImageCreateInfo *)pnext);
407            return;
408        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
409            vn_encode_simple_pointer(enc, pnext);
410            vn_encode_VkStructureType(enc, &pnext->sType);
411            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
412            vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
413            return;
414        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
415            if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
416                break;
417            vn_encode_simple_pointer(enc, pnext);
418            vn_encode_VkStructureType(enc, &pnext->sType);
419            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
420            vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
421            return;
422        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
423            if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
424                break;
425            vn_encode_simple_pointer(enc, pnext);
426            vn_encode_VkStructureType(enc, &pnext->sType);
427            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
428            vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
429            return;
430        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
431            vn_encode_simple_pointer(enc, pnext);
432            vn_encode_VkStructureType(enc, &pnext->sType);
433            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
434            vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
435            return;
436        default:
437            /* ignore unknown/unsupported struct */
438            break;
439        }
440        pnext = pnext->pNext;
441    }
442
443    vn_encode_simple_pointer(enc, NULL);
444}
445
446static inline void
447vn_encode_VkImageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
448{
449    /* skip val->{sType,pNext} */
450    vn_encode_VkFlags(enc, &val->flags);
451    vn_encode_VkImageType(enc, &val->imageType);
452    vn_encode_VkFormat(enc, &val->format);
453    vn_encode_VkExtent3D(enc, &val->extent);
454    vn_encode_uint32_t(enc, &val->mipLevels);
455    vn_encode_uint32_t(enc, &val->arrayLayers);
456    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
457    vn_encode_VkImageTiling(enc, &val->tiling);
458    vn_encode_VkFlags(enc, &val->usage);
459    vn_encode_VkSharingMode(enc, &val->sharingMode);
460    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
461    if (val->pQueueFamilyIndices) {
462        vn_encode_array_size(enc, val->queueFamilyIndexCount);
463        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
464    } else {
465        vn_encode_array_size(enc, 0);
466    }
467    vn_encode_VkImageLayout(enc, &val->initialLayout);
468}
469
470static inline void
471vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
472{
473    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
474    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO });
475    vn_encode_VkImageCreateInfo_pnext(enc, val->pNext);
476    vn_encode_VkImageCreateInfo_self(enc, val);
477}
478
479/* struct VkBindImageMemoryDeviceGroupInfo chain */
480
481static inline size_t
482vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(const void *val)
483{
484    /* no known/supported struct */
485    return vn_sizeof_simple_pointer(NULL);
486}
487
488static inline size_t
489vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(const VkBindImageMemoryDeviceGroupInfo *val)
490{
491    size_t size = 0;
492    /* skip val->{sType,pNext} */
493    size += vn_sizeof_uint32_t(&val->deviceIndexCount);
494    if (val->pDeviceIndices) {
495        size += vn_sizeof_array_size(val->deviceIndexCount);
496        size += vn_sizeof_uint32_t_array(val->pDeviceIndices, val->deviceIndexCount);
497    } else {
498        size += vn_sizeof_array_size(0);
499    }
500    size += vn_sizeof_uint32_t(&val->splitInstanceBindRegionCount);
501    if (val->pSplitInstanceBindRegions) {
502        size += vn_sizeof_array_size(val->splitInstanceBindRegionCount);
503        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
504            size += vn_sizeof_VkRect2D(&val->pSplitInstanceBindRegions[i]);
505    } else {
506        size += vn_sizeof_array_size(0);
507    }
508    return size;
509}
510
511static inline size_t
512vn_sizeof_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo *val)
513{
514    size_t size = 0;
515
516    size += vn_sizeof_VkStructureType(&val->sType);
517    size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(val->pNext);
518    size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(val);
519
520    return size;
521}
522
523static inline void
524vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val)
525{
526    /* no known/supported struct */
527    vn_encode_simple_pointer(enc, NULL);
528}
529
530static inline void
531vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
532{
533    /* skip val->{sType,pNext} */
534    vn_encode_uint32_t(enc, &val->deviceIndexCount);
535    if (val->pDeviceIndices) {
536        vn_encode_array_size(enc, val->deviceIndexCount);
537        vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount);
538    } else {
539        vn_encode_array_size(enc, 0);
540    }
541    vn_encode_uint32_t(enc, &val->splitInstanceBindRegionCount);
542    if (val->pSplitInstanceBindRegions) {
543        vn_encode_array_size(enc, val->splitInstanceBindRegionCount);
544        for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
545            vn_encode_VkRect2D(enc, &val->pSplitInstanceBindRegions[i]);
546    } else {
547        vn_encode_array_size(enc, 0);
548    }
549}
550
551static inline void
552vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
553{
554    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO);
555    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO });
556    vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(enc, val->pNext);
557    vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, val);
558}
559
560/* struct VkBindImagePlaneMemoryInfo chain */
561
562static inline size_t
563vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(const void *val)
564{
565    /* no known/supported struct */
566    return vn_sizeof_simple_pointer(NULL);
567}
568
569static inline size_t
570vn_sizeof_VkBindImagePlaneMemoryInfo_self(const VkBindImagePlaneMemoryInfo *val)
571{
572    size_t size = 0;
573    /* skip val->{sType,pNext} */
574    size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
575    return size;
576}
577
578static inline size_t
579vn_sizeof_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo *val)
580{
581    size_t size = 0;
582
583    size += vn_sizeof_VkStructureType(&val->sType);
584    size += vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(val->pNext);
585    size += vn_sizeof_VkBindImagePlaneMemoryInfo_self(val);
586
587    return size;
588}
589
590static inline void
591vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
592{
593    /* no known/supported struct */
594    vn_encode_simple_pointer(enc, NULL);
595}
596
597static inline void
598vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
599{
600    /* skip val->{sType,pNext} */
601    vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
602}
603
604static inline void
605vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
606{
607    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO);
608    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO });
609    vn_encode_VkBindImagePlaneMemoryInfo_pnext(enc, val->pNext);
610    vn_encode_VkBindImagePlaneMemoryInfo_self(enc, val);
611}
612
613/* struct VkBindImageMemoryInfo chain */
614
615static inline size_t
616vn_sizeof_VkBindImageMemoryInfo_pnext(const void *val)
617{
618    const VkBaseInStructure *pnext = val;
619    size_t size = 0;
620
621    while (pnext) {
622        switch ((int32_t)pnext->sType) {
623        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
624            size += vn_sizeof_simple_pointer(pnext);
625            size += vn_sizeof_VkStructureType(&pnext->sType);
626            size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext);
627            size += vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self((const VkBindImageMemoryDeviceGroupInfo *)pnext);
628            return size;
629        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
630            size += vn_sizeof_simple_pointer(pnext);
631            size += vn_sizeof_VkStructureType(&pnext->sType);
632            size += vn_sizeof_VkBindImageMemoryInfo_pnext(pnext->pNext);
633            size += vn_sizeof_VkBindImagePlaneMemoryInfo_self((const VkBindImagePlaneMemoryInfo *)pnext);
634            return size;
635        default:
636            /* ignore unknown/unsupported struct */
637            break;
638        }
639        pnext = pnext->pNext;
640    }
641
642    return vn_sizeof_simple_pointer(NULL);
643}
644
645static inline size_t
646vn_sizeof_VkBindImageMemoryInfo_self(const VkBindImageMemoryInfo *val)
647{
648    size_t size = 0;
649    /* skip val->{sType,pNext} */
650    size += vn_sizeof_VkImage(&val->image);
651    size += vn_sizeof_VkDeviceMemory(&val->memory);
652    size += vn_sizeof_VkDeviceSize(&val->memoryOffset);
653    return size;
654}
655
656static inline size_t
657vn_sizeof_VkBindImageMemoryInfo(const VkBindImageMemoryInfo *val)
658{
659    size_t size = 0;
660
661    size += vn_sizeof_VkStructureType(&val->sType);
662    size += vn_sizeof_VkBindImageMemoryInfo_pnext(val->pNext);
663    size += vn_sizeof_VkBindImageMemoryInfo_self(val);
664
665    return size;
666}
667
668static inline void
669vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
670{
671    const VkBaseInStructure *pnext = val;
672
673    while (pnext) {
674        switch ((int32_t)pnext->sType) {
675        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
676            vn_encode_simple_pointer(enc, pnext);
677            vn_encode_VkStructureType(enc, &pnext->sType);
678            vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
679            vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, (const VkBindImageMemoryDeviceGroupInfo *)pnext);
680            return;
681        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
682            vn_encode_simple_pointer(enc, pnext);
683            vn_encode_VkStructureType(enc, &pnext->sType);
684            vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
685            vn_encode_VkBindImagePlaneMemoryInfo_self(enc, (const VkBindImagePlaneMemoryInfo *)pnext);
686            return;
687        default:
688            /* ignore unknown/unsupported struct */
689            break;
690        }
691        pnext = pnext->pNext;
692    }
693
694    vn_encode_simple_pointer(enc, NULL);
695}
696
697static inline void
698vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
699{
700    /* skip val->{sType,pNext} */
701    vn_encode_VkImage(enc, &val->image);
702    vn_encode_VkDeviceMemory(enc, &val->memory);
703    vn_encode_VkDeviceSize(enc, &val->memoryOffset);
704}
705
706static inline void
707vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
708{
709    assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
710    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO });
711    vn_encode_VkBindImageMemoryInfo_pnext(enc, val->pNext);
712    vn_encode_VkBindImageMemoryInfo_self(enc, val);
713}
714
715/* struct VkImagePlaneMemoryRequirementsInfo chain */
716
717static inline size_t
718vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(const void *val)
719{
720    /* no known/supported struct */
721    return vn_sizeof_simple_pointer(NULL);
722}
723
724static inline size_t
725vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(const VkImagePlaneMemoryRequirementsInfo *val)
726{
727    size_t size = 0;
728    /* skip val->{sType,pNext} */
729    size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
730    return size;
731}
732
733static inline size_t
734vn_sizeof_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo *val)
735{
736    size_t size = 0;
737
738    size += vn_sizeof_VkStructureType(&val->sType);
739    size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(val->pNext);
740    size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(val);
741
742    return size;
743}
744
745static inline void
746vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(struct vn_cs_encoder *enc, const void *val)
747{
748    /* no known/supported struct */
749    vn_encode_simple_pointer(enc, NULL);
750}
751
752static inline void
753vn_encode_VkImagePlaneMemoryRequirementsInfo_self(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val)
754{
755    /* skip val->{sType,pNext} */
756    vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
757}
758
759static inline void
760vn_encode_VkImagePlaneMemoryRequirementsInfo(struct vn_cs_encoder *enc, const VkImagePlaneMemoryRequirementsInfo *val)
761{
762    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO);
763    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO });
764    vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(enc, val->pNext);
765    vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, val);
766}
767
768/* struct VkImageMemoryRequirementsInfo2 chain */
769
770static inline size_t
771vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(const void *val)
772{
773    const VkBaseInStructure *pnext = val;
774    size_t size = 0;
775
776    while (pnext) {
777        switch ((int32_t)pnext->sType) {
778        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
779            size += vn_sizeof_simple_pointer(pnext);
780            size += vn_sizeof_VkStructureType(&pnext->sType);
781            size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(pnext->pNext);
782            size += vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self((const VkImagePlaneMemoryRequirementsInfo *)pnext);
783            return size;
784        default:
785            /* ignore unknown/unsupported struct */
786            break;
787        }
788        pnext = pnext->pNext;
789    }
790
791    return vn_sizeof_simple_pointer(NULL);
792}
793
794static inline size_t
795vn_sizeof_VkImageMemoryRequirementsInfo2_self(const VkImageMemoryRequirementsInfo2 *val)
796{
797    size_t size = 0;
798    /* skip val->{sType,pNext} */
799    size += vn_sizeof_VkImage(&val->image);
800    return size;
801}
802
803static inline size_t
804vn_sizeof_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 *val)
805{
806    size_t size = 0;
807
808    size += vn_sizeof_VkStructureType(&val->sType);
809    size += vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(val->pNext);
810    size += vn_sizeof_VkImageMemoryRequirementsInfo2_self(val);
811
812    return size;
813}
814
815static inline void
816vn_encode_VkImageMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
817{
818    const VkBaseInStructure *pnext = val;
819
820    while (pnext) {
821        switch ((int32_t)pnext->sType) {
822        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
823            vn_encode_simple_pointer(enc, pnext);
824            vn_encode_VkStructureType(enc, &pnext->sType);
825            vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, pnext->pNext);
826            vn_encode_VkImagePlaneMemoryRequirementsInfo_self(enc, (const VkImagePlaneMemoryRequirementsInfo *)pnext);
827            return;
828        default:
829            /* ignore unknown/unsupported struct */
830            break;
831        }
832        pnext = pnext->pNext;
833    }
834
835    vn_encode_simple_pointer(enc, NULL);
836}
837
838static inline void
839vn_encode_VkImageMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val)
840{
841    /* skip val->{sType,pNext} */
842    vn_encode_VkImage(enc, &val->image);
843}
844
845static inline void
846vn_encode_VkImageMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageMemoryRequirementsInfo2 *val)
847{
848    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2);
849    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 });
850    vn_encode_VkImageMemoryRequirementsInfo2_pnext(enc, val->pNext);
851    vn_encode_VkImageMemoryRequirementsInfo2_self(enc, val);
852}
853
854/* struct VkImageSparseMemoryRequirementsInfo2 chain */
855
856static inline size_t
857vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(const void *val)
858{
859    /* no known/supported struct */
860    return vn_sizeof_simple_pointer(NULL);
861}
862
863static inline size_t
864vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(const VkImageSparseMemoryRequirementsInfo2 *val)
865{
866    size_t size = 0;
867    /* skip val->{sType,pNext} */
868    size += vn_sizeof_VkImage(&val->image);
869    return size;
870}
871
872static inline size_t
873vn_sizeof_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2 *val)
874{
875    size_t size = 0;
876
877    size += vn_sizeof_VkStructureType(&val->sType);
878    size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(val->pNext);
879    size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(val);
880
881    return size;
882}
883
884static inline void
885vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
886{
887    /* no known/supported struct */
888    vn_encode_simple_pointer(enc, NULL);
889}
890
891static inline void
892vn_encode_VkImageSparseMemoryRequirementsInfo2_self(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val)
893{
894    /* skip val->{sType,pNext} */
895    vn_encode_VkImage(enc, &val->image);
896}
897
898static inline void
899vn_encode_VkImageSparseMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkImageSparseMemoryRequirementsInfo2 *val)
900{
901    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2);
902    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 });
903    vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(enc, val->pNext);
904    vn_encode_VkImageSparseMemoryRequirementsInfo2_self(enc, val);
905}
906
907/* struct VkSparseImageMemoryRequirements2 chain */
908
909static inline size_t
910vn_sizeof_VkSparseImageMemoryRequirements2_pnext(const void *val)
911{
912    /* no known/supported struct */
913    return vn_sizeof_simple_pointer(NULL);
914}
915
916static inline size_t
917vn_sizeof_VkSparseImageMemoryRequirements2_self(const VkSparseImageMemoryRequirements2 *val)
918{
919    size_t size = 0;
920    /* skip val->{sType,pNext} */
921    size += vn_sizeof_VkSparseImageMemoryRequirements(&val->memoryRequirements);
922    return size;
923}
924
925static inline size_t
926vn_sizeof_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2 *val)
927{
928    size_t size = 0;
929
930    size += vn_sizeof_VkStructureType(&val->sType);
931    size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext(val->pNext);
932    size += vn_sizeof_VkSparseImageMemoryRequirements2_self(val);
933
934    return size;
935}
936
937static inline void
938vn_decode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val)
939{
940    /* no known/supported struct */
941    if (vn_decode_simple_pointer(dec))
942        assert(false);
943}
944
945static inline void
946vn_decode_VkSparseImageMemoryRequirements2_self(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
947{
948    /* skip val->{sType,pNext} */
949    vn_decode_VkSparseImageMemoryRequirements(dec, &val->memoryRequirements);
950}
951
952static inline void
953vn_decode_VkSparseImageMemoryRequirements2(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
954{
955    VkStructureType stype;
956    vn_decode_VkStructureType(dec, &stype);
957    assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
958
959    assert(val->sType == stype);
960    vn_decode_VkSparseImageMemoryRequirements2_pnext(dec, val->pNext);
961    vn_decode_VkSparseImageMemoryRequirements2_self(dec, val);
962}
963
964static inline size_t
965vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(const void *val)
966{
967    /* no known/supported struct */
968    return vn_sizeof_simple_pointer(NULL);
969}
970
971static inline size_t
972vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(const VkSparseImageMemoryRequirements2 *val)
973{
974    size_t size = 0;
975    /* skip val->{sType,pNext} */
976    size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&val->memoryRequirements);
977    return size;
978}
979
980static inline size_t
981vn_sizeof_VkSparseImageMemoryRequirements2_partial(const VkSparseImageMemoryRequirements2 *val)
982{
983    size_t size = 0;
984
985    size += vn_sizeof_VkStructureType(&val->sType);
986    size += vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(val->pNext);
987    size += vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(val);
988
989    return size;
990}
991
992static inline void
993vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
994{
995    /* no known/supported struct */
996    vn_encode_simple_pointer(enc, NULL);
997}
998
999static inline void
1000vn_encode_VkSparseImageMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
1001{
1002    /* skip val->{sType,pNext} */
1003    vn_encode_VkSparseImageMemoryRequirements_partial(enc, &val->memoryRequirements);
1004}
1005
1006static inline void
1007vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
1008{
1009    assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
1010    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 });
1011    vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(enc, val->pNext);
1012    vn_encode_VkSparseImageMemoryRequirements2_self_partial(enc, val);
1013}
1014
1015/* struct VkDeviceImageMemoryRequirements chain */
1016
1017static inline size_t
1018vn_sizeof_VkDeviceImageMemoryRequirements_pnext(const void *val)
1019{
1020    /* no known/supported struct */
1021    return vn_sizeof_simple_pointer(NULL);
1022}
1023
1024static inline size_t
1025vn_sizeof_VkDeviceImageMemoryRequirements_self(const VkDeviceImageMemoryRequirements *val)
1026{
1027    size_t size = 0;
1028    /* skip val->{sType,pNext} */
1029    size += vn_sizeof_simple_pointer(val->pCreateInfo);
1030    if (val->pCreateInfo)
1031        size += vn_sizeof_VkImageCreateInfo(val->pCreateInfo);
1032    size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
1033    return size;
1034}
1035
1036static inline size_t
1037vn_sizeof_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements *val)
1038{
1039    size_t size = 0;
1040
1041    size += vn_sizeof_VkStructureType(&val->sType);
1042    size += vn_sizeof_VkDeviceImageMemoryRequirements_pnext(val->pNext);
1043    size += vn_sizeof_VkDeviceImageMemoryRequirements_self(val);
1044
1045    return size;
1046}
1047
1048static inline void
1049vn_encode_VkDeviceImageMemoryRequirements_pnext(struct vn_cs_encoder *enc, const void *val)
1050{
1051    /* no known/supported struct */
1052    vn_encode_simple_pointer(enc, NULL);
1053}
1054
1055static inline void
1056vn_encode_VkDeviceImageMemoryRequirements_self(struct vn_cs_encoder *enc, const VkDeviceImageMemoryRequirements *val)
1057{
1058    /* skip val->{sType,pNext} */
1059    if (vn_encode_simple_pointer(enc, val->pCreateInfo))
1060        vn_encode_VkImageCreateInfo(enc, val->pCreateInfo);
1061    vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
1062}
1063
1064static inline void
1065vn_encode_VkDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, const VkDeviceImageMemoryRequirements *val)
1066{
1067    assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS);
1068    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS });
1069    vn_encode_VkDeviceImageMemoryRequirements_pnext(enc, val->pNext);
1070    vn_encode_VkDeviceImageMemoryRequirements_self(enc, val);
1071}
1072
1073/* struct VkImageDrmFormatModifierPropertiesEXT chain */
1074
1075static inline size_t
1076vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(const void *val)
1077{
1078    /* no known/supported struct */
1079    return vn_sizeof_simple_pointer(NULL);
1080}
1081
1082static inline size_t
1083vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(const VkImageDrmFormatModifierPropertiesEXT *val)
1084{
1085    size_t size = 0;
1086    /* skip val->{sType,pNext} */
1087    size += vn_sizeof_uint64_t(&val->drmFormatModifier);
1088    return size;
1089}
1090
1091static inline size_t
1092vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT *val)
1093{
1094    size_t size = 0;
1095
1096    size += vn_sizeof_VkStructureType(&val->sType);
1097    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(val->pNext);
1098    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(val);
1099
1100    return size;
1101}
1102
1103static inline void
1104vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
1105{
1106    /* no known/supported struct */
1107    if (vn_decode_simple_pointer(dec))
1108        assert(false);
1109}
1110
1111static inline void
1112vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
1113{
1114    /* skip val->{sType,pNext} */
1115    vn_decode_uint64_t(dec, &val->drmFormatModifier);
1116}
1117
1118static inline void
1119vn_decode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
1120{
1121    VkStructureType stype;
1122    vn_decode_VkStructureType(dec, &stype);
1123    assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
1124
1125    assert(val->sType == stype);
1126    vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(dec, val->pNext);
1127    vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(dec, val);
1128}
1129
1130static inline size_t
1131vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(const void *val)
1132{
1133    /* no known/supported struct */
1134    return vn_sizeof_simple_pointer(NULL);
1135}
1136
1137static inline size_t
1138vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(const VkImageDrmFormatModifierPropertiesEXT *val)
1139{
1140    size_t size = 0;
1141    /* skip val->{sType,pNext} */
1142    /* skip val->drmFormatModifier */
1143    return size;
1144}
1145
1146static inline size_t
1147vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(const VkImageDrmFormatModifierPropertiesEXT *val)
1148{
1149    size_t size = 0;
1150
1151    size += vn_sizeof_VkStructureType(&val->sType);
1152    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(val->pNext);
1153    size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(val);
1154
1155    return size;
1156}
1157
1158static inline void
1159vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1160{
1161    /* no known/supported struct */
1162    vn_encode_simple_pointer(enc, NULL);
1163}
1164
1165static inline void
1166vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
1167{
1168    /* skip val->{sType,pNext} */
1169    /* skip val->drmFormatModifier */
1170}
1171
1172static inline void
1173vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
1174{
1175    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
1176    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT });
1177    vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(enc, val->pNext);
1178    vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(enc, val);
1179}
1180
1181static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1182{
1183    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1184    const VkFlags cmd_flags = 0;
1185    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1186
1187    cmd_size += vn_sizeof_VkDevice(&device);
1188    cmd_size += vn_sizeof_VkImage(&image);
1189    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1190    if (pMemoryRequirements)
1191        cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements);
1192
1193    return cmd_size;
1194}
1195
1196static inline void vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1197{
1198    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1199
1200    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1201    vn_encode_VkFlags(enc, &cmd_flags);
1202
1203    vn_encode_VkDevice(enc, &device);
1204    vn_encode_VkImage(enc, &image);
1205    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1206        vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements);
1207}
1208
1209static inline size_t vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1210{
1211    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1212    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1213
1214    /* skip device */
1215    /* skip image */
1216    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1217    if (pMemoryRequirements)
1218        cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements);
1219
1220    return cmd_size;
1221}
1222
1223static inline void vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1224{
1225    VkCommandTypeEXT command_type;
1226    vn_decode_VkCommandTypeEXT(dec, &command_type);
1227    assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT);
1228
1229    /* skip device */
1230    /* skip image */
1231    if (vn_decode_simple_pointer(dec)) {
1232        vn_decode_VkMemoryRequirements(dec, pMemoryRequirements);
1233    } else {
1234        pMemoryRequirements = NULL;
1235    }
1236}
1237
1238static inline size_t vn_sizeof_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1239{
1240    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1241    const VkFlags cmd_flags = 0;
1242    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1243
1244    cmd_size += vn_sizeof_VkDevice(&device);
1245    cmd_size += vn_sizeof_VkImage(&image);
1246    cmd_size += vn_sizeof_VkDeviceMemory(&memory);
1247    cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset);
1248
1249    return cmd_size;
1250}
1251
1252static inline void vn_encode_vkBindImageMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1253{
1254    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1255
1256    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1257    vn_encode_VkFlags(enc, &cmd_flags);
1258
1259    vn_encode_VkDevice(enc, &device);
1260    vn_encode_VkImage(enc, &image);
1261    vn_encode_VkDeviceMemory(enc, &memory);
1262    vn_encode_VkDeviceSize(enc, &memoryOffset);
1263}
1264
1265static inline size_t vn_sizeof_vkBindImageMemory_reply(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1266{
1267    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1268    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1269
1270    VkResult ret;
1271    cmd_size += vn_sizeof_VkResult(&ret);
1272    /* skip device */
1273    /* skip image */
1274    /* skip memory */
1275    /* skip memoryOffset */
1276
1277    return cmd_size;
1278}
1279
1280static inline VkResult vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1281{
1282    VkCommandTypeEXT command_type;
1283    vn_decode_VkCommandTypeEXT(dec, &command_type);
1284    assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory_EXT);
1285
1286    VkResult ret;
1287    vn_decode_VkResult(dec, &ret);
1288    /* skip device */
1289    /* skip image */
1290    /* skip memory */
1291    /* skip memoryOffset */
1292
1293    return ret;
1294}
1295
1296static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1297{
1298    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1299    const VkFlags cmd_flags = 0;
1300    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1301
1302    cmd_size += vn_sizeof_VkDevice(&device);
1303    cmd_size += vn_sizeof_VkImage(&image);
1304    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1305    if (pSparseMemoryRequirementCount)
1306        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1307    if (pSparseMemoryRequirements) {
1308        cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1309        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1310            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&pSparseMemoryRequirements[i]);
1311    } else {
1312        cmd_size += vn_sizeof_array_size(0);
1313    }
1314
1315    return cmd_size;
1316}
1317
1318static inline void vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1319{
1320    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1321
1322    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1323    vn_encode_VkFlags(enc, &cmd_flags);
1324
1325    vn_encode_VkDevice(enc, &device);
1326    vn_encode_VkImage(enc, &image);
1327    if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1328        vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1329    if (pSparseMemoryRequirements) {
1330        vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1331        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1332            vn_encode_VkSparseImageMemoryRequirements_partial(enc, &pSparseMemoryRequirements[i]);
1333    } else {
1334        vn_encode_array_size(enc, 0);
1335    }
1336}
1337
1338static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1339{
1340    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1341    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1342
1343    /* skip device */
1344    /* skip image */
1345    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1346    if (pSparseMemoryRequirementCount)
1347        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1348    if (pSparseMemoryRequirements) {
1349        cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1350        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1351            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements(&pSparseMemoryRequirements[i]);
1352    } else {
1353        cmd_size += vn_sizeof_array_size(0);
1354    }
1355
1356    return cmd_size;
1357}
1358
1359static inline void vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1360{
1361    VkCommandTypeEXT command_type;
1362    vn_decode_VkCommandTypeEXT(dec, &command_type);
1363    assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT);
1364
1365    /* skip device */
1366    /* skip image */
1367    if (vn_decode_simple_pointer(dec)) {
1368        vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1369    } else {
1370        pSparseMemoryRequirementCount = NULL;
1371    }
1372    if (vn_peek_array_size(dec)) {
1373        const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1374        for (uint32_t i = 0; i < iter_count; i++)
1375            vn_decode_VkSparseImageMemoryRequirements(dec, &pSparseMemoryRequirements[i]);
1376    } else {
1377        vn_decode_array_size_unchecked(dec);
1378        pSparseMemoryRequirements = NULL;
1379    }
1380}
1381
1382static inline size_t vn_sizeof_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1383{
1384    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1385    const VkFlags cmd_flags = 0;
1386    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1387
1388    cmd_size += vn_sizeof_VkDevice(&device);
1389    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
1390    if (pCreateInfo)
1391        cmd_size += vn_sizeof_VkImageCreateInfo(pCreateInfo);
1392    cmd_size += vn_sizeof_simple_pointer(pAllocator);
1393    if (pAllocator)
1394        assert(false);
1395    cmd_size += vn_sizeof_simple_pointer(pImage);
1396    if (pImage)
1397        cmd_size += vn_sizeof_VkImage(pImage);
1398
1399    return cmd_size;
1400}
1401
1402static inline void vn_encode_vkCreateImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1403{
1404    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1405
1406    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1407    vn_encode_VkFlags(enc, &cmd_flags);
1408
1409    vn_encode_VkDevice(enc, &device);
1410    if (vn_encode_simple_pointer(enc, pCreateInfo))
1411        vn_encode_VkImageCreateInfo(enc, pCreateInfo);
1412    if (vn_encode_simple_pointer(enc, pAllocator))
1413        assert(false);
1414    if (vn_encode_simple_pointer(enc, pImage))
1415        vn_encode_VkImage(enc, pImage);
1416}
1417
1418static inline size_t vn_sizeof_vkCreateImage_reply(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1419{
1420    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1421    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1422
1423    VkResult ret;
1424    cmd_size += vn_sizeof_VkResult(&ret);
1425    /* skip device */
1426    /* skip pCreateInfo */
1427    /* skip pAllocator */
1428    cmd_size += vn_sizeof_simple_pointer(pImage);
1429    if (pImage)
1430        cmd_size += vn_sizeof_VkImage(pImage);
1431
1432    return cmd_size;
1433}
1434
1435static inline VkResult vn_decode_vkCreateImage_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1436{
1437    VkCommandTypeEXT command_type;
1438    vn_decode_VkCommandTypeEXT(dec, &command_type);
1439    assert(command_type == VK_COMMAND_TYPE_vkCreateImage_EXT);
1440
1441    VkResult ret;
1442    vn_decode_VkResult(dec, &ret);
1443    /* skip device */
1444    /* skip pCreateInfo */
1445    /* skip pAllocator */
1446    if (vn_decode_simple_pointer(dec)) {
1447        vn_decode_VkImage(dec, pImage);
1448    } else {
1449        pImage = NULL;
1450    }
1451
1452    return ret;
1453}
1454
1455static inline size_t vn_sizeof_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1456{
1457    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1458    const VkFlags cmd_flags = 0;
1459    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1460
1461    cmd_size += vn_sizeof_VkDevice(&device);
1462    cmd_size += vn_sizeof_VkImage(&image);
1463    cmd_size += vn_sizeof_simple_pointer(pAllocator);
1464    if (pAllocator)
1465        assert(false);
1466
1467    return cmd_size;
1468}
1469
1470static inline void vn_encode_vkDestroyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1471{
1472    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1473
1474    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1475    vn_encode_VkFlags(enc, &cmd_flags);
1476
1477    vn_encode_VkDevice(enc, &device);
1478    vn_encode_VkImage(enc, &image);
1479    if (vn_encode_simple_pointer(enc, pAllocator))
1480        assert(false);
1481}
1482
1483static inline size_t vn_sizeof_vkDestroyImage_reply(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1484{
1485    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1486    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1487
1488    /* skip device */
1489    /* skip image */
1490    /* skip pAllocator */
1491
1492    return cmd_size;
1493}
1494
1495static inline void vn_decode_vkDestroyImage_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1496{
1497    VkCommandTypeEXT command_type;
1498    vn_decode_VkCommandTypeEXT(dec, &command_type);
1499    assert(command_type == VK_COMMAND_TYPE_vkDestroyImage_EXT);
1500
1501    /* skip device */
1502    /* skip image */
1503    /* skip pAllocator */
1504}
1505
1506static inline size_t vn_sizeof_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1507{
1508    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1509    const VkFlags cmd_flags = 0;
1510    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1511
1512    cmd_size += vn_sizeof_VkDevice(&device);
1513    cmd_size += vn_sizeof_VkImage(&image);
1514    cmd_size += vn_sizeof_simple_pointer(pSubresource);
1515    if (pSubresource)
1516        cmd_size += vn_sizeof_VkImageSubresource(pSubresource);
1517    cmd_size += vn_sizeof_simple_pointer(pLayout);
1518    if (pLayout)
1519        cmd_size += vn_sizeof_VkSubresourceLayout_partial(pLayout);
1520
1521    return cmd_size;
1522}
1523
1524static inline void vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1525{
1526    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1527
1528    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1529    vn_encode_VkFlags(enc, &cmd_flags);
1530
1531    vn_encode_VkDevice(enc, &device);
1532    vn_encode_VkImage(enc, &image);
1533    if (vn_encode_simple_pointer(enc, pSubresource))
1534        vn_encode_VkImageSubresource(enc, pSubresource);
1535    if (vn_encode_simple_pointer(enc, pLayout))
1536        vn_encode_VkSubresourceLayout_partial(enc, pLayout);
1537}
1538
1539static inline size_t vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1540{
1541    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1542    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1543
1544    /* skip device */
1545    /* skip image */
1546    /* skip pSubresource */
1547    cmd_size += vn_sizeof_simple_pointer(pLayout);
1548    if (pLayout)
1549        cmd_size += vn_sizeof_VkSubresourceLayout(pLayout);
1550
1551    return cmd_size;
1552}
1553
1554static inline void vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1555{
1556    VkCommandTypeEXT command_type;
1557    vn_decode_VkCommandTypeEXT(dec, &command_type);
1558    assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT);
1559
1560    /* skip device */
1561    /* skip image */
1562    /* skip pSubresource */
1563    if (vn_decode_simple_pointer(dec)) {
1564        vn_decode_VkSubresourceLayout(dec, pLayout);
1565    } else {
1566        pLayout = NULL;
1567    }
1568}
1569
1570static inline size_t vn_sizeof_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1571{
1572    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1573    const VkFlags cmd_flags = 0;
1574    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1575
1576    cmd_size += vn_sizeof_VkDevice(&device);
1577    cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
1578    if (pBindInfos) {
1579        cmd_size += vn_sizeof_array_size(bindInfoCount);
1580        for (uint32_t i = 0; i < bindInfoCount; i++)
1581            cmd_size += vn_sizeof_VkBindImageMemoryInfo(&pBindInfos[i]);
1582    } else {
1583        cmd_size += vn_sizeof_array_size(0);
1584    }
1585
1586    return cmd_size;
1587}
1588
1589static inline void vn_encode_vkBindImageMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1590{
1591    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1592
1593    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1594    vn_encode_VkFlags(enc, &cmd_flags);
1595
1596    vn_encode_VkDevice(enc, &device);
1597    vn_encode_uint32_t(enc, &bindInfoCount);
1598    if (pBindInfos) {
1599        vn_encode_array_size(enc, bindInfoCount);
1600        for (uint32_t i = 0; i < bindInfoCount; i++)
1601            vn_encode_VkBindImageMemoryInfo(enc, &pBindInfos[i]);
1602    } else {
1603        vn_encode_array_size(enc, 0);
1604    }
1605}
1606
1607static inline size_t vn_sizeof_vkBindImageMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1608{
1609    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1610    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1611
1612    VkResult ret;
1613    cmd_size += vn_sizeof_VkResult(&ret);
1614    /* skip device */
1615    /* skip bindInfoCount */
1616    /* skip pBindInfos */
1617
1618    return cmd_size;
1619}
1620
1621static inline VkResult vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1622{
1623    VkCommandTypeEXT command_type;
1624    vn_decode_VkCommandTypeEXT(dec, &command_type);
1625    assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory2_EXT);
1626
1627    VkResult ret;
1628    vn_decode_VkResult(dec, &ret);
1629    /* skip device */
1630    /* skip bindInfoCount */
1631    /* skip pBindInfos */
1632
1633    return ret;
1634}
1635
1636static inline size_t vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1637{
1638    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1639    const VkFlags cmd_flags = 0;
1640    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1641
1642    cmd_size += vn_sizeof_VkDevice(&device);
1643    cmd_size += vn_sizeof_simple_pointer(pInfo);
1644    if (pInfo)
1645        cmd_size += vn_sizeof_VkImageMemoryRequirementsInfo2(pInfo);
1646    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1647    if (pMemoryRequirements)
1648        cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
1649
1650    return cmd_size;
1651}
1652
1653static inline void vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1654{
1655    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1656
1657    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1658    vn_encode_VkFlags(enc, &cmd_flags);
1659
1660    vn_encode_VkDevice(enc, &device);
1661    if (vn_encode_simple_pointer(enc, pInfo))
1662        vn_encode_VkImageMemoryRequirementsInfo2(enc, pInfo);
1663    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1664        vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
1665}
1666
1667static inline size_t vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1668{
1669    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1670    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1671
1672    /* skip device */
1673    /* skip pInfo */
1674    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1675    if (pMemoryRequirements)
1676        cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
1677
1678    return cmd_size;
1679}
1680
1681static inline void vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1682{
1683    VkCommandTypeEXT command_type;
1684    vn_decode_VkCommandTypeEXT(dec, &command_type);
1685    assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT);
1686
1687    /* skip device */
1688    /* skip pInfo */
1689    if (vn_decode_simple_pointer(dec)) {
1690        vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
1691    } else {
1692        pMemoryRequirements = NULL;
1693    }
1694}
1695
1696static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1697{
1698    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1699    const VkFlags cmd_flags = 0;
1700    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1701
1702    cmd_size += vn_sizeof_VkDevice(&device);
1703    cmd_size += vn_sizeof_simple_pointer(pInfo);
1704    if (pInfo)
1705        cmd_size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2(pInfo);
1706    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1707    if (pSparseMemoryRequirementCount)
1708        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1709    if (pSparseMemoryRequirements) {
1710        cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1711        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1712            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
1713    } else {
1714        cmd_size += vn_sizeof_array_size(0);
1715    }
1716
1717    return cmd_size;
1718}
1719
1720static inline void vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1721{
1722    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1723
1724    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1725    vn_encode_VkFlags(enc, &cmd_flags);
1726
1727    vn_encode_VkDevice(enc, &device);
1728    if (vn_encode_simple_pointer(enc, pInfo))
1729        vn_encode_VkImageSparseMemoryRequirementsInfo2(enc, pInfo);
1730    if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1731        vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1732    if (pSparseMemoryRequirements) {
1733        vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1734        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1735            vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
1736    } else {
1737        vn_encode_array_size(enc, 0);
1738    }
1739}
1740
1741static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1742{
1743    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1744    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1745
1746    /* skip device */
1747    /* skip pInfo */
1748    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1749    if (pSparseMemoryRequirementCount)
1750        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1751    if (pSparseMemoryRequirements) {
1752        cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1753        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1754            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
1755    } else {
1756        cmd_size += vn_sizeof_array_size(0);
1757    }
1758
1759    return cmd_size;
1760}
1761
1762static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1763{
1764    VkCommandTypeEXT command_type;
1765    vn_decode_VkCommandTypeEXT(dec, &command_type);
1766    assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT);
1767
1768    /* skip device */
1769    /* skip pInfo */
1770    if (vn_decode_simple_pointer(dec)) {
1771        vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1772    } else {
1773        pSparseMemoryRequirementCount = NULL;
1774    }
1775    if (vn_peek_array_size(dec)) {
1776        const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1777        for (uint32_t i = 0; i < iter_count; i++)
1778            vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
1779    } else {
1780        vn_decode_array_size_unchecked(dec);
1781        pSparseMemoryRequirements = NULL;
1782    }
1783}
1784
1785static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1786{
1787    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
1788    const VkFlags cmd_flags = 0;
1789    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1790
1791    cmd_size += vn_sizeof_VkDevice(&device);
1792    cmd_size += vn_sizeof_simple_pointer(pInfo);
1793    if (pInfo)
1794        cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
1795    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1796    if (pMemoryRequirements)
1797        cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
1798
1799    return cmd_size;
1800}
1801
1802static inline void vn_encode_vkGetDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1803{
1804    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
1805
1806    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1807    vn_encode_VkFlags(enc, &cmd_flags);
1808
1809    vn_encode_VkDevice(enc, &device);
1810    if (vn_encode_simple_pointer(enc, pInfo))
1811        vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
1812    if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1813        vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
1814}
1815
1816static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1817{
1818    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
1819    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1820
1821    /* skip device */
1822    /* skip pInfo */
1823    cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1824    if (pMemoryRequirements)
1825        cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
1826
1827    return cmd_size;
1828}
1829
1830static inline void vn_decode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1831{
1832    VkCommandTypeEXT command_type;
1833    vn_decode_VkCommandTypeEXT(dec, &command_type);
1834    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT);
1835
1836    /* skip device */
1837    /* skip pInfo */
1838    if (vn_decode_simple_pointer(dec)) {
1839        vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
1840    } else {
1841        pMemoryRequirements = NULL;
1842    }
1843}
1844
1845static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1846{
1847    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
1848    const VkFlags cmd_flags = 0;
1849    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1850
1851    cmd_size += vn_sizeof_VkDevice(&device);
1852    cmd_size += vn_sizeof_simple_pointer(pInfo);
1853    if (pInfo)
1854        cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
1855    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1856    if (pSparseMemoryRequirementCount)
1857        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1858    if (pSparseMemoryRequirements) {
1859        cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1860        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1861            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
1862    } else {
1863        cmd_size += vn_sizeof_array_size(0);
1864    }
1865
1866    return cmd_size;
1867}
1868
1869static inline void vn_encode_vkGetDeviceImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1870{
1871    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
1872
1873    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1874    vn_encode_VkFlags(enc, &cmd_flags);
1875
1876    vn_encode_VkDevice(enc, &device);
1877    if (vn_encode_simple_pointer(enc, pInfo))
1878        vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
1879    if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1880        vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1881    if (pSparseMemoryRequirements) {
1882        vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1883        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1884            vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
1885    } else {
1886        vn_encode_array_size(enc, 0);
1887    }
1888}
1889
1890static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1891{
1892    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
1893    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1894
1895    /* skip device */
1896    /* skip pInfo */
1897    cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1898    if (pSparseMemoryRequirementCount)
1899        cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1900    if (pSparseMemoryRequirements) {
1901        cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1902        for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1903            cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
1904    } else {
1905        cmd_size += vn_sizeof_array_size(0);
1906    }
1907
1908    return cmd_size;
1909}
1910
1911static inline void vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1912{
1913    VkCommandTypeEXT command_type;
1914    vn_decode_VkCommandTypeEXT(dec, &command_type);
1915    assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT);
1916
1917    /* skip device */
1918    /* skip pInfo */
1919    if (vn_decode_simple_pointer(dec)) {
1920        vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1921    } else {
1922        pSparseMemoryRequirementCount = NULL;
1923    }
1924    if (vn_peek_array_size(dec)) {
1925        const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1926        for (uint32_t i = 0; i < iter_count; i++)
1927            vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
1928    } else {
1929        vn_decode_array_size_unchecked(dec);
1930        pSparseMemoryRequirements = NULL;
1931    }
1932}
1933
1934static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1935{
1936    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
1937    const VkFlags cmd_flags = 0;
1938    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1939
1940    cmd_size += vn_sizeof_VkDevice(&device);
1941    cmd_size += vn_sizeof_VkImage(&image);
1942    cmd_size += vn_sizeof_simple_pointer(pProperties);
1943    if (pProperties)
1944        cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(pProperties);
1945
1946    return cmd_size;
1947}
1948
1949static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1950{
1951    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
1952
1953    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1954    vn_encode_VkFlags(enc, &cmd_flags);
1955
1956    vn_encode_VkDevice(enc, &device);
1957    vn_encode_VkImage(enc, &image);
1958    if (vn_encode_simple_pointer(enc, pProperties))
1959        vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(enc, pProperties);
1960}
1961
1962static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1963{
1964    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
1965    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1966
1967    VkResult ret;
1968    cmd_size += vn_sizeof_VkResult(&ret);
1969    /* skip device */
1970    /* skip image */
1971    cmd_size += vn_sizeof_simple_pointer(pProperties);
1972    if (pProperties)
1973        cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(pProperties);
1974
1975    return cmd_size;
1976}
1977
1978static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1979{
1980    VkCommandTypeEXT command_type;
1981    vn_decode_VkCommandTypeEXT(dec, &command_type);
1982    assert(command_type == VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT);
1983
1984    VkResult ret;
1985    vn_decode_VkResult(dec, &ret);
1986    /* skip device */
1987    /* skip image */
1988    if (vn_decode_simple_pointer(dec)) {
1989        vn_decode_VkImageDrmFormatModifierPropertiesEXT(dec, pProperties);
1990    } else {
1991        pProperties = NULL;
1992    }
1993
1994    return ret;
1995}
1996
1997static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit)
1998{
1999    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2000    void *cmd_data = local_cmd_data;
2001    size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
2002    if (cmd_size > sizeof(local_cmd_data)) {
2003        cmd_data = malloc(cmd_size);
2004        if (!cmd_data)
2005            cmd_size = 0;
2006    }
2007    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0;
2008
2009    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2010    if (cmd_size) {
2011        vn_encode_vkGetImageMemoryRequirements(enc, cmd_flags, device, image, pMemoryRequirements);
2012        vn_instance_submit_command(vn_instance, submit);
2013        if (cmd_data != local_cmd_data)
2014            free(cmd_data);
2015    }
2016}
2017
2018static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
2019{
2020    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2021    void *cmd_data = local_cmd_data;
2022    size_t cmd_size = vn_sizeof_vkBindImageMemory(device, image, memory, memoryOffset);
2023    if (cmd_size > sizeof(local_cmd_data)) {
2024        cmd_data = malloc(cmd_size);
2025        if (!cmd_data)
2026            cmd_size = 0;
2027    }
2028    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0;
2029
2030    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2031    if (cmd_size) {
2032        vn_encode_vkBindImageMemory(enc, cmd_flags, device, image, memory, memoryOffset);
2033        vn_instance_submit_command(vn_instance, submit);
2034        if (cmd_data != local_cmd_data)
2035            free(cmd_data);
2036    }
2037}
2038
2039static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
2040{
2041    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2042    void *cmd_data = local_cmd_data;
2043    size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2044    if (cmd_size > sizeof(local_cmd_data)) {
2045        cmd_data = malloc(cmd_size);
2046        if (!cmd_data)
2047            cmd_size = 0;
2048    }
2049    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2050
2051    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2052    if (cmd_size) {
2053        vn_encode_vkGetImageSparseMemoryRequirements(enc, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2054        vn_instance_submit_command(vn_instance, submit);
2055        if (cmd_data != local_cmd_data)
2056            free(cmd_data);
2057    }
2058}
2059
2060static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_instance_submit_command *submit)
2061{
2062    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2063    void *cmd_data = local_cmd_data;
2064    size_t cmd_size = vn_sizeof_vkCreateImage(device, pCreateInfo, pAllocator, pImage);
2065    if (cmd_size > sizeof(local_cmd_data)) {
2066        cmd_data = malloc(cmd_size);
2067        if (!cmd_data)
2068            cmd_size = 0;
2069    }
2070    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0;
2071
2072    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2073    if (cmd_size) {
2074        vn_encode_vkCreateImage(enc, cmd_flags, device, pCreateInfo, pAllocator, pImage);
2075        vn_instance_submit_command(vn_instance, submit);
2076        if (cmd_data != local_cmd_data)
2077            free(cmd_data);
2078    }
2079}
2080
2081static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
2082{
2083    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2084    void *cmd_data = local_cmd_data;
2085    size_t cmd_size = vn_sizeof_vkDestroyImage(device, image, pAllocator);
2086    if (cmd_size > sizeof(local_cmd_data)) {
2087        cmd_data = malloc(cmd_size);
2088        if (!cmd_data)
2089            cmd_size = 0;
2090    }
2091    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0;
2092
2093    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2094    if (cmd_size) {
2095        vn_encode_vkDestroyImage(enc, cmd_flags, device, image, pAllocator);
2096        vn_instance_submit_command(vn_instance, submit);
2097        if (cmd_data != local_cmd_data)
2098            free(cmd_data);
2099    }
2100}
2101
2102static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_instance_submit_command *submit)
2103{
2104    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2105    void *cmd_data = local_cmd_data;
2106    size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
2107    if (cmd_size > sizeof(local_cmd_data)) {
2108        cmd_data = malloc(cmd_size);
2109        if (!cmd_data)
2110            cmd_size = 0;
2111    }
2112    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0;
2113
2114    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2115    if (cmd_size) {
2116        vn_encode_vkGetImageSubresourceLayout(enc, cmd_flags, device, image, pSubresource, pLayout);
2117        vn_instance_submit_command(vn_instance, submit);
2118        if (cmd_data != local_cmd_data)
2119            free(cmd_data);
2120    }
2121}
2122
2123static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
2124{
2125    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2126    void *cmd_data = local_cmd_data;
2127    size_t cmd_size = vn_sizeof_vkBindImageMemory2(device, bindInfoCount, pBindInfos);
2128    if (cmd_size > sizeof(local_cmd_data)) {
2129        cmd_data = malloc(cmd_size);
2130        if (!cmd_data)
2131            cmd_size = 0;
2132    }
2133    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
2134
2135    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2136    if (cmd_size) {
2137        vn_encode_vkBindImageMemory2(enc, cmd_flags, device, bindInfoCount, pBindInfos);
2138        vn_instance_submit_command(vn_instance, submit);
2139        if (cmd_data != local_cmd_data)
2140            free(cmd_data);
2141    }
2142}
2143
2144static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
2145{
2146    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2147    void *cmd_data = local_cmd_data;
2148    size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
2149    if (cmd_size > sizeof(local_cmd_data)) {
2150        cmd_data = malloc(cmd_size);
2151        if (!cmd_data)
2152            cmd_size = 0;
2153    }
2154    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
2155
2156    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2157    if (cmd_size) {
2158        vn_encode_vkGetImageMemoryRequirements2(enc, cmd_flags, device, pInfo, pMemoryRequirements);
2159        vn_instance_submit_command(vn_instance, submit);
2160        if (cmd_data != local_cmd_data)
2161            free(cmd_data);
2162    }
2163}
2164
2165static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
2166{
2167    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2168    void *cmd_data = local_cmd_data;
2169    size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2170    if (cmd_size > sizeof(local_cmd_data)) {
2171        cmd_data = malloc(cmd_size);
2172        if (!cmd_data)
2173            cmd_size = 0;
2174    }
2175    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2176
2177    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2178    if (cmd_size) {
2179        vn_encode_vkGetImageSparseMemoryRequirements2(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2180        vn_instance_submit_command(vn_instance, submit);
2181        if (cmd_data != local_cmd_data)
2182            free(cmd_data);
2183    }
2184}
2185
2186static inline void vn_submit_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
2187{
2188    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2189    void *cmd_data = local_cmd_data;
2190    size_t cmd_size = vn_sizeof_vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
2191    if (cmd_size > sizeof(local_cmd_data)) {
2192        cmd_data = malloc(cmd_size);
2193        if (!cmd_data)
2194            cmd_size = 0;
2195    }
2196    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(device, pInfo, pMemoryRequirements) : 0;
2197
2198    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2199    if (cmd_size) {
2200        vn_encode_vkGetDeviceImageMemoryRequirements(enc, cmd_flags, device, pInfo, pMemoryRequirements);
2201        vn_instance_submit_command(vn_instance, submit);
2202        if (cmd_data != local_cmd_data)
2203            free(cmd_data);
2204    }
2205}
2206
2207static inline void vn_submit_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
2208{
2209    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2210    void *cmd_data = local_cmd_data;
2211    size_t cmd_size = vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2212    if (cmd_size > sizeof(local_cmd_data)) {
2213        cmd_data = malloc(cmd_size);
2214        if (!cmd_data)
2215            cmd_size = 0;
2216    }
2217    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2218
2219    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2220    if (cmd_size) {
2221        vn_encode_vkGetDeviceImageSparseMemoryRequirements(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2222        vn_instance_submit_command(vn_instance, submit);
2223        if (cmd_data != local_cmd_data)
2224            free(cmd_data);
2225    }
2226}
2227
2228static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit)
2229{
2230    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2231    void *cmd_data = local_cmd_data;
2232    size_t cmd_size = vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
2233    if (cmd_size > sizeof(local_cmd_data)) {
2234        cmd_data = malloc(cmd_size);
2235        if (!cmd_data)
2236            cmd_size = 0;
2237    }
2238    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0;
2239
2240    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2241    if (cmd_size) {
2242        vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(enc, cmd_flags, device, image, pProperties);
2243        vn_instance_submit_command(vn_instance, submit);
2244        if (cmd_data != local_cmd_data)
2245            free(cmd_data);
2246    }
2247}
2248
2249static inline void vn_call_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
2250{
2251    VN_TRACE_FUNC();
2252
2253    struct vn_instance_submit_command submit;
2254    vn_submit_vkGetImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit);
2255    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2256    if (dec) {
2257        vn_decode_vkGetImageMemoryRequirements_reply(dec, device, image, pMemoryRequirements);
2258        vn_instance_free_command_reply(vn_instance, &submit);
2259    }
2260}
2261
2262static inline void vn_async_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
2263{
2264    struct vn_instance_submit_command submit;
2265    vn_submit_vkGetImageMemoryRequirements(vn_instance, 0, device, image, pMemoryRequirements, &submit);
2266}
2267
2268static inline VkResult vn_call_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
2269{
2270    VN_TRACE_FUNC();
2271
2272    struct vn_instance_submit_command submit;
2273    vn_submit_vkBindImageMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit);
2274    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2275    if (dec) {
2276        const VkResult ret = vn_decode_vkBindImageMemory_reply(dec, device, image, memory, memoryOffset);
2277        vn_instance_free_command_reply(vn_instance, &submit);
2278        return ret;
2279    } else {
2280        return VK_ERROR_OUT_OF_HOST_MEMORY;
2281    }
2282}
2283
2284static inline void vn_async_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
2285{
2286    struct vn_instance_submit_command submit;
2287    vn_submit_vkBindImageMemory(vn_instance, 0, device, image, memory, memoryOffset, &submit);
2288}
2289
2290static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
2291{
2292    VN_TRACE_FUNC();
2293
2294    struct vn_instance_submit_command submit;
2295    vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2296    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2297    if (dec) {
2298        vn_decode_vkGetImageSparseMemoryRequirements_reply(dec, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2299        vn_instance_free_command_reply(vn_instance, &submit);
2300    }
2301}
2302
2303static inline void vn_async_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
2304{
2305    struct vn_instance_submit_command submit;
2306    vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, 0, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2307}
2308
2309static inline VkResult vn_call_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
2310{
2311    VN_TRACE_FUNC();
2312
2313    struct vn_instance_submit_command submit;
2314    vn_submit_vkCreateImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit);
2315    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2316    if (dec) {
2317        const VkResult ret = vn_decode_vkCreateImage_reply(dec, device, pCreateInfo, pAllocator, pImage);
2318        vn_instance_free_command_reply(vn_instance, &submit);
2319        return ret;
2320    } else {
2321        return VK_ERROR_OUT_OF_HOST_MEMORY;
2322    }
2323}
2324
2325static inline void vn_async_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
2326{
2327    struct vn_instance_submit_command submit;
2328    vn_submit_vkCreateImage(vn_instance, 0, device, pCreateInfo, pAllocator, pImage, &submit);
2329}
2330
2331static inline void vn_call_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
2332{
2333    VN_TRACE_FUNC();
2334
2335    struct vn_instance_submit_command submit;
2336    vn_submit_vkDestroyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit);
2337    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2338    if (dec) {
2339        vn_decode_vkDestroyImage_reply(dec, device, image, pAllocator);
2340        vn_instance_free_command_reply(vn_instance, &submit);
2341    }
2342}
2343
2344static inline void vn_async_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
2345{
2346    struct vn_instance_submit_command submit;
2347    vn_submit_vkDestroyImage(vn_instance, 0, device, image, pAllocator, &submit);
2348}
2349
2350static inline void vn_call_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
2351{
2352    VN_TRACE_FUNC();
2353
2354    struct vn_instance_submit_command submit;
2355    vn_submit_vkGetImageSubresourceLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
2356    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2357    if (dec) {
2358        vn_decode_vkGetImageSubresourceLayout_reply(dec, device, image, pSubresource, pLayout);
2359        vn_instance_free_command_reply(vn_instance, &submit);
2360    }
2361}
2362
2363static inline void vn_async_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
2364{
2365    struct vn_instance_submit_command submit;
2366    vn_submit_vkGetImageSubresourceLayout(vn_instance, 0, device, image, pSubresource, pLayout, &submit);
2367}
2368
2369static inline VkResult vn_call_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
2370{
2371    VN_TRACE_FUNC();
2372
2373    struct vn_instance_submit_command submit;
2374    vn_submit_vkBindImageMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
2375    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2376    if (dec) {
2377        const VkResult ret = vn_decode_vkBindImageMemory2_reply(dec, device, bindInfoCount, pBindInfos);
2378        vn_instance_free_command_reply(vn_instance, &submit);
2379        return ret;
2380    } else {
2381        return VK_ERROR_OUT_OF_HOST_MEMORY;
2382    }
2383}
2384
2385static inline void vn_async_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
2386{
2387    struct vn_instance_submit_command submit;
2388    vn_submit_vkBindImageMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit);
2389}
2390
2391static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2392{
2393    VN_TRACE_FUNC();
2394
2395    struct vn_instance_submit_command submit;
2396    vn_submit_vkGetImageMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
2397    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2398    if (dec) {
2399        vn_decode_vkGetImageMemoryRequirements2_reply(dec, device, pInfo, pMemoryRequirements);
2400        vn_instance_free_command_reply(vn_instance, &submit);
2401    }
2402}
2403
2404static inline void vn_async_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2405{
2406    struct vn_instance_submit_command submit;
2407    vn_submit_vkGetImageMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
2408}
2409
2410static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2411{
2412    VN_TRACE_FUNC();
2413
2414    struct vn_instance_submit_command submit;
2415    vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2416    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2417    if (dec) {
2418        vn_decode_vkGetImageSparseMemoryRequirements2_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2419        vn_instance_free_command_reply(vn_instance, &submit);
2420    }
2421}
2422
2423static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2424{
2425    struct vn_instance_submit_command submit;
2426    vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2427}
2428
2429static inline void vn_call_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2430{
2431    VN_TRACE_FUNC();
2432
2433    struct vn_instance_submit_command submit;
2434    vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
2435    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2436    if (dec) {
2437        vn_decode_vkGetDeviceImageMemoryRequirements_reply(dec, device, pInfo, pMemoryRequirements);
2438        vn_instance_free_command_reply(vn_instance, &submit);
2439    }
2440}
2441
2442static inline void vn_async_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2443{
2444    struct vn_instance_submit_command submit;
2445    vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
2446}
2447
2448static inline void vn_call_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2449{
2450    VN_TRACE_FUNC();
2451
2452    struct vn_instance_submit_command submit;
2453    vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2454    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2455    if (dec) {
2456        vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2457        vn_instance_free_command_reply(vn_instance, &submit);
2458    }
2459}
2460
2461static inline void vn_async_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2462{
2463    struct vn_instance_submit_command submit;
2464    vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2465}
2466
2467static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2468{
2469    VN_TRACE_FUNC();
2470
2471    struct vn_instance_submit_command submit;
2472    vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit);
2473    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2474    if (dec) {
2475        const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(dec, device, image, pProperties);
2476        vn_instance_free_command_reply(vn_instance, &submit);
2477        return ret;
2478    } else {
2479        return VK_ERROR_OUT_OF_HOST_MEMORY;
2480    }
2481}
2482
2483static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2484{
2485    struct vn_instance_submit_command submit;
2486    vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, 0, device, image, pProperties, &submit);
2487}
2488
2489#endif /* VN_PROTOCOL_DRIVER_IMAGE_H */
2490