xref: /aosp_15_r20/external/mesa3d/src/virtio/venus-protocol/vn_protocol_driver_image.h (revision 6104692788411f58d303aa86923a9ff6ecaded22)
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_ring.h"
12 #include "vn_protocol_driver_structs.h"
13 
14 /* struct VkSparseImageMemoryRequirements */
15 
16 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements * val)17 vn_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 
28 static inline void
vn_decode_VkSparseImageMemoryRequirements(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements * val)29 vn_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 
38 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements_partial(const VkSparseImageMemoryRequirements * val)39 vn_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 
50 static inline void
vn_encode_VkSparseImageMemoryRequirements_partial(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements * val)51 vn_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 
62 static inline size_t
vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(const void * val)63 vn_sizeof_VkExternalMemoryImageCreateInfo_pnext(const void *val)
64 {
65     /* no known/supported struct */
66     return vn_sizeof_simple_pointer(NULL);
67 }
68 
69 static inline size_t
vn_sizeof_VkExternalMemoryImageCreateInfo_self(const VkExternalMemoryImageCreateInfo * val)70 vn_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 
78 static inline size_t
vn_sizeof_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo * val)79 vn_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 
90 static inline void
vn_encode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)91 vn_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 
97 static inline void
vn_encode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_encoder * enc,const VkExternalMemoryImageCreateInfo * val)98 vn_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 
104 static inline void
vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder * enc,const VkExternalMemoryImageCreateInfo * val)105 vn_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 
115 static inline size_t
vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(const void * val)116 vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_pnext(const void *val)
117 {
118     /* no known/supported struct */
119     return vn_sizeof_simple_pointer(NULL);
120 }
121 
122 static inline size_t
vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT_self(const VkImageDrmFormatModifierListCreateInfoEXT * val)123 vn_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 
137 static inline size_t
vn_sizeof_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT * val)138 vn_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 
149 static inline void
vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)150 vn_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 
156 static inline void
vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierListCreateInfoEXT * val)157 vn_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 
169 static inline void
vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierListCreateInfoEXT * val)170 vn_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 
180 static inline size_t
vn_sizeof_VkSubresourceLayout(const VkSubresourceLayout * val)181 vn_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 
192 static inline void
vn_encode_VkSubresourceLayout(struct vn_cs_encoder * enc,const VkSubresourceLayout * val)193 vn_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 
202 static inline void
vn_decode_VkSubresourceLayout(struct vn_cs_decoder * dec,VkSubresourceLayout * val)203 vn_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 
212 static inline size_t
vn_sizeof_VkSubresourceLayout_partial(const VkSubresourceLayout * val)213 vn_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 
224 static inline void
vn_encode_VkSubresourceLayout_partial(struct vn_cs_encoder * enc,const VkSubresourceLayout * val)225 vn_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 
236 static inline size_t
vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(const void * val)237 vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(const void *val)
238 {
239     /* no known/supported struct */
240     return vn_sizeof_simple_pointer(NULL);
241 }
242 
243 static inline size_t
vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(const VkImageDrmFormatModifierExplicitCreateInfoEXT * val)244 vn_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 
260 static inline size_t
vn_sizeof_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT * val)261 vn_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 
272 static inline void
vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)273 vn_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 
279 static inline void
vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierExplicitCreateInfoEXT * val)280 vn_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 
294 static inline void
vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierExplicitCreateInfoEXT * val)295 vn_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 
305 static inline size_t
vn_sizeof_VkImageCreateInfo_pnext(const void * val)306 vn_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 
357 static inline size_t
vn_sizeof_VkImageCreateInfo_self(const VkImageCreateInfo * val)358 vn_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->sharingMode == VK_SHARING_MODE_CONCURRENT) {
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 
383 static inline size_t
vn_sizeof_VkImageCreateInfo(const VkImageCreateInfo * val)384 vn_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 
395 static inline void
vn_encode_VkImageCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)396 vn_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 
446 static inline void
vn_encode_VkImageCreateInfo_self(struct vn_cs_encoder * enc,const VkImageCreateInfo * val)447 vn_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->sharingMode == VK_SHARING_MODE_CONCURRENT) {
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 
470 static inline void
vn_encode_VkImageCreateInfo(struct vn_cs_encoder * enc,const VkImageCreateInfo * val)471 vn_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 
481 static inline size_t
vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(const void * val)482 vn_sizeof_VkBindImageMemoryDeviceGroupInfo_pnext(const void *val)
483 {
484     /* no known/supported struct */
485     return vn_sizeof_simple_pointer(NULL);
486 }
487 
488 static inline size_t
vn_sizeof_VkBindImageMemoryDeviceGroupInfo_self(const VkBindImageMemoryDeviceGroupInfo * val)489 vn_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 
511 static inline size_t
vn_sizeof_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo * val)512 vn_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 
523 static inline void
vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder * enc,const void * val)524 vn_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 
530 static inline void
vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder * enc,const VkBindImageMemoryDeviceGroupInfo * val)531 vn_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 
551 static inline void
vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder * enc,const VkBindImageMemoryDeviceGroupInfo * val)552 vn_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 
562 static inline size_t
vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(const void * val)563 vn_sizeof_VkBindImagePlaneMemoryInfo_pnext(const void *val)
564 {
565     /* no known/supported struct */
566     return vn_sizeof_simple_pointer(NULL);
567 }
568 
569 static inline size_t
vn_sizeof_VkBindImagePlaneMemoryInfo_self(const VkBindImagePlaneMemoryInfo * val)570 vn_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 
578 static inline size_t
vn_sizeof_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo * val)579 vn_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 
590 static inline void
vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder * enc,const void * val)591 vn_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 
597 static inline void
vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder * enc,const VkBindImagePlaneMemoryInfo * val)598 vn_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 
604 static inline void
vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder * enc,const VkBindImagePlaneMemoryInfo * val)605 vn_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 
615 static inline size_t
vn_sizeof_VkBindImageMemoryInfo_pnext(const void * val)616 vn_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 
645 static inline size_t
vn_sizeof_VkBindImageMemoryInfo_self(const VkBindImageMemoryInfo * val)646 vn_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 
656 static inline size_t
vn_sizeof_VkBindImageMemoryInfo(const VkBindImageMemoryInfo * val)657 vn_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 
668 static inline void
vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder * enc,const void * val)669 vn_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 
697 static inline void
vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder * enc,const VkBindImageMemoryInfo * val)698 vn_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 
706 static inline void
vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder * enc,const VkBindImageMemoryInfo * val)707 vn_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 
717 static inline size_t
vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(const void * val)718 vn_sizeof_VkImagePlaneMemoryRequirementsInfo_pnext(const void *val)
719 {
720     /* no known/supported struct */
721     return vn_sizeof_simple_pointer(NULL);
722 }
723 
724 static inline size_t
vn_sizeof_VkImagePlaneMemoryRequirementsInfo_self(const VkImagePlaneMemoryRequirementsInfo * val)725 vn_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 
733 static inline size_t
vn_sizeof_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo * val)734 vn_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 
745 static inline void
vn_encode_VkImagePlaneMemoryRequirementsInfo_pnext(struct vn_cs_encoder * enc,const void * val)746 vn_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 
752 static inline void
vn_encode_VkImagePlaneMemoryRequirementsInfo_self(struct vn_cs_encoder * enc,const VkImagePlaneMemoryRequirementsInfo * val)753 vn_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 
759 static inline void
vn_encode_VkImagePlaneMemoryRequirementsInfo(struct vn_cs_encoder * enc,const VkImagePlaneMemoryRequirementsInfo * val)760 vn_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 
770 static inline size_t
vn_sizeof_VkImageMemoryRequirementsInfo2_pnext(const void * val)771 vn_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 
794 static inline size_t
vn_sizeof_VkImageMemoryRequirementsInfo2_self(const VkImageMemoryRequirementsInfo2 * val)795 vn_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 
803 static inline size_t
vn_sizeof_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2 * val)804 vn_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 
815 static inline void
vn_encode_VkImageMemoryRequirementsInfo2_pnext(struct vn_cs_encoder * enc,const void * val)816 vn_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 
838 static inline void
vn_encode_VkImageMemoryRequirementsInfo2_self(struct vn_cs_encoder * enc,const VkImageMemoryRequirementsInfo2 * val)839 vn_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 
845 static inline void
vn_encode_VkImageMemoryRequirementsInfo2(struct vn_cs_encoder * enc,const VkImageMemoryRequirementsInfo2 * val)846 vn_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 
856 static inline size_t
vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(const void * val)857 vn_sizeof_VkImageSparseMemoryRequirementsInfo2_pnext(const void *val)
858 {
859     /* no known/supported struct */
860     return vn_sizeof_simple_pointer(NULL);
861 }
862 
863 static inline size_t
vn_sizeof_VkImageSparseMemoryRequirementsInfo2_self(const VkImageSparseMemoryRequirementsInfo2 * val)864 vn_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 
872 static inline size_t
vn_sizeof_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2 * val)873 vn_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 
884 static inline void
vn_encode_VkImageSparseMemoryRequirementsInfo2_pnext(struct vn_cs_encoder * enc,const void * val)885 vn_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 
891 static inline void
vn_encode_VkImageSparseMemoryRequirementsInfo2_self(struct vn_cs_encoder * enc,const VkImageSparseMemoryRequirementsInfo2 * val)892 vn_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 
898 static inline void
vn_encode_VkImageSparseMemoryRequirementsInfo2(struct vn_cs_encoder * enc,const VkImageSparseMemoryRequirementsInfo2 * val)899 vn_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 
909 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements2_pnext(const void * val)910 vn_sizeof_VkSparseImageMemoryRequirements2_pnext(const void *val)
911 {
912     /* no known/supported struct */
913     return vn_sizeof_simple_pointer(NULL);
914 }
915 
916 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements2_self(const VkSparseImageMemoryRequirements2 * val)917 vn_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 
925 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2 * val)926 vn_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 
937 static inline void
vn_decode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_decoder * dec,const void * val)938 vn_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 
945 static inline void
vn_decode_VkSparseImageMemoryRequirements2_self(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements2 * val)946 vn_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 
952 static inline void
vn_decode_VkSparseImageMemoryRequirements2(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements2 * val)953 vn_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 
964 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(const void * val)965 vn_sizeof_VkSparseImageMemoryRequirements2_pnext_partial(const void *val)
966 {
967     /* no known/supported struct */
968     return vn_sizeof_simple_pointer(NULL);
969 }
970 
971 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements2_self_partial(const VkSparseImageMemoryRequirements2 * val)972 vn_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 
980 static inline size_t
vn_sizeof_VkSparseImageMemoryRequirements2_partial(const VkSparseImageMemoryRequirements2 * val)981 vn_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 
992 static inline void
vn_encode_VkSparseImageMemoryRequirements2_pnext_partial(struct vn_cs_encoder * enc,const void * val)993 vn_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 
999 static inline void
vn_encode_VkSparseImageMemoryRequirements2_self_partial(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements2 * val)1000 vn_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 
1006 static inline void
vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements2 * val)1007 vn_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 
1017 static inline size_t
vn_sizeof_VkDeviceImageMemoryRequirements_pnext(const void * val)1018 vn_sizeof_VkDeviceImageMemoryRequirements_pnext(const void *val)
1019 {
1020     /* no known/supported struct */
1021     return vn_sizeof_simple_pointer(NULL);
1022 }
1023 
1024 static inline size_t
vn_sizeof_VkDeviceImageMemoryRequirements_self(const VkDeviceImageMemoryRequirements * val)1025 vn_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 
1036 static inline size_t
vn_sizeof_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements * val)1037 vn_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 
1048 static inline void
vn_encode_VkDeviceImageMemoryRequirements_pnext(struct vn_cs_encoder * enc,const void * val)1049 vn_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 
1055 static inline void
vn_encode_VkDeviceImageMemoryRequirements_self(struct vn_cs_encoder * enc,const VkDeviceImageMemoryRequirements * val)1056 vn_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 
1064 static inline void
vn_encode_VkDeviceImageMemoryRequirements(struct vn_cs_encoder * enc,const VkDeviceImageMemoryRequirements * val)1065 vn_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 
1075 static inline size_t
vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(const void * val)1076 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext(const void *val)
1077 {
1078     /* no known/supported struct */
1079     return vn_sizeof_simple_pointer(NULL);
1080 }
1081 
1082 static inline size_t
vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self(const VkImageDrmFormatModifierPropertiesEXT * val)1083 vn_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 
1091 static inline size_t
vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT * val)1092 vn_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 
1103 static inline void
vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)1104 vn_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 
1111 static inline void
vn_decode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_decoder * dec,VkImageDrmFormatModifierPropertiesEXT * val)1112 vn_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 
1118 static inline void
vn_decode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_decoder * dec,VkImageDrmFormatModifierPropertiesEXT * val)1119 vn_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 
1130 static inline size_t
vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(const void * val)1131 vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(const void *val)
1132 {
1133     /* no known/supported struct */
1134     return vn_sizeof_simple_pointer(NULL);
1135 }
1136 
1137 static inline size_t
vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_self_partial(const VkImageDrmFormatModifierPropertiesEXT * val)1138 vn_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 
1146 static inline size_t
vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(const VkImageDrmFormatModifierPropertiesEXT * val)1147 vn_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 
1158 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)1159 vn_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 
1165 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierPropertiesEXT * val)1166 vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
1167 {
1168     /* skip val->{sType,pNext} */
1169     /* skip val->drmFormatModifier */
1170 }
1171 
1172 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierPropertiesEXT * val)1173 vn_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 
1181 /* struct VkImageSubresource2KHR chain */
1182 
1183 static inline size_t
vn_sizeof_VkImageSubresource2KHR_pnext(const void * val)1184 vn_sizeof_VkImageSubresource2KHR_pnext(const void *val)
1185 {
1186     /* no known/supported struct */
1187     return vn_sizeof_simple_pointer(NULL);
1188 }
1189 
1190 static inline size_t
vn_sizeof_VkImageSubresource2KHR_self(const VkImageSubresource2KHR * val)1191 vn_sizeof_VkImageSubresource2KHR_self(const VkImageSubresource2KHR *val)
1192 {
1193     size_t size = 0;
1194     /* skip val->{sType,pNext} */
1195     size += vn_sizeof_VkImageSubresource(&val->imageSubresource);
1196     return size;
1197 }
1198 
1199 static inline size_t
vn_sizeof_VkImageSubresource2KHR(const VkImageSubresource2KHR * val)1200 vn_sizeof_VkImageSubresource2KHR(const VkImageSubresource2KHR *val)
1201 {
1202     size_t size = 0;
1203 
1204     size += vn_sizeof_VkStructureType(&val->sType);
1205     size += vn_sizeof_VkImageSubresource2KHR_pnext(val->pNext);
1206     size += vn_sizeof_VkImageSubresource2KHR_self(val);
1207 
1208     return size;
1209 }
1210 
1211 static inline void
vn_encode_VkImageSubresource2KHR_pnext(struct vn_cs_encoder * enc,const void * val)1212 vn_encode_VkImageSubresource2KHR_pnext(struct vn_cs_encoder *enc, const void *val)
1213 {
1214     /* no known/supported struct */
1215     vn_encode_simple_pointer(enc, NULL);
1216 }
1217 
1218 static inline void
vn_encode_VkImageSubresource2KHR_self(struct vn_cs_encoder * enc,const VkImageSubresource2KHR * val)1219 vn_encode_VkImageSubresource2KHR_self(struct vn_cs_encoder *enc, const VkImageSubresource2KHR *val)
1220 {
1221     /* skip val->{sType,pNext} */
1222     vn_encode_VkImageSubresource(enc, &val->imageSubresource);
1223 }
1224 
1225 static inline void
vn_encode_VkImageSubresource2KHR(struct vn_cs_encoder * enc,const VkImageSubresource2KHR * val)1226 vn_encode_VkImageSubresource2KHR(struct vn_cs_encoder *enc, const VkImageSubresource2KHR *val)
1227 {
1228     assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR);
1229     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR });
1230     vn_encode_VkImageSubresource2KHR_pnext(enc, val->pNext);
1231     vn_encode_VkImageSubresource2KHR_self(enc, val);
1232 }
1233 
1234 /* struct VkSubresourceLayout2KHR chain */
1235 
1236 static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_pnext(const void * val)1237 vn_sizeof_VkSubresourceLayout2KHR_pnext(const void *val)
1238 {
1239     /* no known/supported struct */
1240     return vn_sizeof_simple_pointer(NULL);
1241 }
1242 
1243 static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_self(const VkSubresourceLayout2KHR * val)1244 vn_sizeof_VkSubresourceLayout2KHR_self(const VkSubresourceLayout2KHR *val)
1245 {
1246     size_t size = 0;
1247     /* skip val->{sType,pNext} */
1248     size += vn_sizeof_VkSubresourceLayout(&val->subresourceLayout);
1249     return size;
1250 }
1251 
1252 static inline size_t
vn_sizeof_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR * val)1253 vn_sizeof_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR *val)
1254 {
1255     size_t size = 0;
1256 
1257     size += vn_sizeof_VkStructureType(&val->sType);
1258     size += vn_sizeof_VkSubresourceLayout2KHR_pnext(val->pNext);
1259     size += vn_sizeof_VkSubresourceLayout2KHR_self(val);
1260 
1261     return size;
1262 }
1263 
1264 static inline void
vn_decode_VkSubresourceLayout2KHR_pnext(struct vn_cs_decoder * dec,const void * val)1265 vn_decode_VkSubresourceLayout2KHR_pnext(struct vn_cs_decoder *dec, const void *val)
1266 {
1267     /* no known/supported struct */
1268     if (vn_decode_simple_pointer(dec))
1269         assert(false);
1270 }
1271 
1272 static inline void
vn_decode_VkSubresourceLayout2KHR_self(struct vn_cs_decoder * dec,VkSubresourceLayout2KHR * val)1273 vn_decode_VkSubresourceLayout2KHR_self(struct vn_cs_decoder *dec, VkSubresourceLayout2KHR *val)
1274 {
1275     /* skip val->{sType,pNext} */
1276     vn_decode_VkSubresourceLayout(dec, &val->subresourceLayout);
1277 }
1278 
1279 static inline void
vn_decode_VkSubresourceLayout2KHR(struct vn_cs_decoder * dec,VkSubresourceLayout2KHR * val)1280 vn_decode_VkSubresourceLayout2KHR(struct vn_cs_decoder *dec, VkSubresourceLayout2KHR *val)
1281 {
1282     VkStructureType stype;
1283     vn_decode_VkStructureType(dec, &stype);
1284     assert(stype == VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR);
1285 
1286     assert(val->sType == stype);
1287     vn_decode_VkSubresourceLayout2KHR_pnext(dec, val->pNext);
1288     vn_decode_VkSubresourceLayout2KHR_self(dec, val);
1289 }
1290 
1291 static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_pnext_partial(const void * val)1292 vn_sizeof_VkSubresourceLayout2KHR_pnext_partial(const void *val)
1293 {
1294     /* no known/supported struct */
1295     return vn_sizeof_simple_pointer(NULL);
1296 }
1297 
1298 static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_self_partial(const VkSubresourceLayout2KHR * val)1299 vn_sizeof_VkSubresourceLayout2KHR_self_partial(const VkSubresourceLayout2KHR *val)
1300 {
1301     size_t size = 0;
1302     /* skip val->{sType,pNext} */
1303     size += vn_sizeof_VkSubresourceLayout_partial(&val->subresourceLayout);
1304     return size;
1305 }
1306 
1307 static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_partial(const VkSubresourceLayout2KHR * val)1308 vn_sizeof_VkSubresourceLayout2KHR_partial(const VkSubresourceLayout2KHR *val)
1309 {
1310     size_t size = 0;
1311 
1312     size += vn_sizeof_VkStructureType(&val->sType);
1313     size += vn_sizeof_VkSubresourceLayout2KHR_pnext_partial(val->pNext);
1314     size += vn_sizeof_VkSubresourceLayout2KHR_self_partial(val);
1315 
1316     return size;
1317 }
1318 
1319 static inline void
vn_encode_VkSubresourceLayout2KHR_pnext_partial(struct vn_cs_encoder * enc,const void * val)1320 vn_encode_VkSubresourceLayout2KHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1321 {
1322     /* no known/supported struct */
1323     vn_encode_simple_pointer(enc, NULL);
1324 }
1325 
1326 static inline void
vn_encode_VkSubresourceLayout2KHR_self_partial(struct vn_cs_encoder * enc,const VkSubresourceLayout2KHR * val)1327 vn_encode_VkSubresourceLayout2KHR_self_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout2KHR *val)
1328 {
1329     /* skip val->{sType,pNext} */
1330     vn_encode_VkSubresourceLayout_partial(enc, &val->subresourceLayout);
1331 }
1332 
1333 static inline void
vn_encode_VkSubresourceLayout2KHR_partial(struct vn_cs_encoder * enc,const VkSubresourceLayout2KHR * val)1334 vn_encode_VkSubresourceLayout2KHR_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout2KHR *val)
1335 {
1336     assert(val->sType == VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR);
1337     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR });
1338     vn_encode_VkSubresourceLayout2KHR_pnext_partial(enc, val->pNext);
1339     vn_encode_VkSubresourceLayout2KHR_self_partial(enc, val);
1340 }
1341 
1342 /* struct VkDeviceImageSubresourceInfoKHR chain */
1343 
1344 static inline size_t
vn_sizeof_VkDeviceImageSubresourceInfoKHR_pnext(const void * val)1345 vn_sizeof_VkDeviceImageSubresourceInfoKHR_pnext(const void *val)
1346 {
1347     /* no known/supported struct */
1348     return vn_sizeof_simple_pointer(NULL);
1349 }
1350 
1351 static inline size_t
vn_sizeof_VkDeviceImageSubresourceInfoKHR_self(const VkDeviceImageSubresourceInfoKHR * val)1352 vn_sizeof_VkDeviceImageSubresourceInfoKHR_self(const VkDeviceImageSubresourceInfoKHR *val)
1353 {
1354     size_t size = 0;
1355     /* skip val->{sType,pNext} */
1356     size += vn_sizeof_simple_pointer(val->pCreateInfo);
1357     if (val->pCreateInfo)
1358         size += vn_sizeof_VkImageCreateInfo(val->pCreateInfo);
1359     size += vn_sizeof_simple_pointer(val->pSubresource);
1360     if (val->pSubresource)
1361         size += vn_sizeof_VkImageSubresource2KHR(val->pSubresource);
1362     return size;
1363 }
1364 
1365 static inline size_t
vn_sizeof_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR * val)1366 vn_sizeof_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR *val)
1367 {
1368     size_t size = 0;
1369 
1370     size += vn_sizeof_VkStructureType(&val->sType);
1371     size += vn_sizeof_VkDeviceImageSubresourceInfoKHR_pnext(val->pNext);
1372     size += vn_sizeof_VkDeviceImageSubresourceInfoKHR_self(val);
1373 
1374     return size;
1375 }
1376 
1377 static inline void
vn_encode_VkDeviceImageSubresourceInfoKHR_pnext(struct vn_cs_encoder * enc,const void * val)1378 vn_encode_VkDeviceImageSubresourceInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
1379 {
1380     /* no known/supported struct */
1381     vn_encode_simple_pointer(enc, NULL);
1382 }
1383 
1384 static inline void
vn_encode_VkDeviceImageSubresourceInfoKHR_self(struct vn_cs_encoder * enc,const VkDeviceImageSubresourceInfoKHR * val)1385 vn_encode_VkDeviceImageSubresourceInfoKHR_self(struct vn_cs_encoder *enc, const VkDeviceImageSubresourceInfoKHR *val)
1386 {
1387     /* skip val->{sType,pNext} */
1388     if (vn_encode_simple_pointer(enc, val->pCreateInfo))
1389         vn_encode_VkImageCreateInfo(enc, val->pCreateInfo);
1390     if (vn_encode_simple_pointer(enc, val->pSubresource))
1391         vn_encode_VkImageSubresource2KHR(enc, val->pSubresource);
1392 }
1393 
1394 static inline void
vn_encode_VkDeviceImageSubresourceInfoKHR(struct vn_cs_encoder * enc,const VkDeviceImageSubresourceInfoKHR * val)1395 vn_encode_VkDeviceImageSubresourceInfoKHR(struct vn_cs_encoder *enc, const VkDeviceImageSubresourceInfoKHR *val)
1396 {
1397     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR);
1398     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR });
1399     vn_encode_VkDeviceImageSubresourceInfoKHR_pnext(enc, val->pNext);
1400     vn_encode_VkDeviceImageSubresourceInfoKHR_self(enc, val);
1401 }
1402 
vn_sizeof_vkGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1403 static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1404 {
1405     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1406     const VkFlags cmd_flags = 0;
1407     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1408 
1409     cmd_size += vn_sizeof_VkDevice(&device);
1410     cmd_size += vn_sizeof_VkImage(&image);
1411     cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1412     if (pMemoryRequirements)
1413         cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements);
1414 
1415     return cmd_size;
1416 }
1417 
vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1418 static inline void vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1419 {
1420     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1421 
1422     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1423     vn_encode_VkFlags(enc, &cmd_flags);
1424 
1425     vn_encode_VkDevice(enc, &device);
1426     vn_encode_VkImage(enc, &image);
1427     if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1428         vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements);
1429 }
1430 
vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1431 static inline size_t vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1432 {
1433     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1434     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1435 
1436     /* skip device */
1437     /* skip image */
1438     cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1439     if (pMemoryRequirements)
1440         cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements);
1441 
1442     return cmd_size;
1443 }
1444 
vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1445 static inline void vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1446 {
1447     VkCommandTypeEXT command_type;
1448     vn_decode_VkCommandTypeEXT(dec, &command_type);
1449     assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT);
1450 
1451     /* skip device */
1452     /* skip image */
1453     if (vn_decode_simple_pointer(dec)) {
1454         vn_decode_VkMemoryRequirements(dec, pMemoryRequirements);
1455     } else {
1456         pMemoryRequirements = NULL;
1457     }
1458 }
1459 
vn_sizeof_vkBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1460 static inline size_t vn_sizeof_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1461 {
1462     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1463     const VkFlags cmd_flags = 0;
1464     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1465 
1466     cmd_size += vn_sizeof_VkDevice(&device);
1467     cmd_size += vn_sizeof_VkImage(&image);
1468     cmd_size += vn_sizeof_VkDeviceMemory(&memory);
1469     cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset);
1470 
1471     return cmd_size;
1472 }
1473 
vn_encode_vkBindImageMemory(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1474 static inline void vn_encode_vkBindImageMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1475 {
1476     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1477 
1478     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1479     vn_encode_VkFlags(enc, &cmd_flags);
1480 
1481     vn_encode_VkDevice(enc, &device);
1482     vn_encode_VkImage(enc, &image);
1483     vn_encode_VkDeviceMemory(enc, &memory);
1484     vn_encode_VkDeviceSize(enc, &memoryOffset);
1485 }
1486 
vn_sizeof_vkBindImageMemory_reply(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1487 static inline size_t vn_sizeof_vkBindImageMemory_reply(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1488 {
1489     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1490     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1491 
1492     VkResult ret;
1493     cmd_size += vn_sizeof_VkResult(&ret);
1494     /* skip device */
1495     /* skip image */
1496     /* skip memory */
1497     /* skip memoryOffset */
1498 
1499     return cmd_size;
1500 }
1501 
vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1502 static inline VkResult vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1503 {
1504     VkCommandTypeEXT command_type;
1505     vn_decode_VkCommandTypeEXT(dec, &command_type);
1506     assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory_EXT);
1507 
1508     VkResult ret;
1509     vn_decode_VkResult(dec, &ret);
1510     /* skip device */
1511     /* skip image */
1512     /* skip memory */
1513     /* skip memoryOffset */
1514 
1515     return ret;
1516 }
1517 
vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1518 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1519 {
1520     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1521     const VkFlags cmd_flags = 0;
1522     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1523 
1524     cmd_size += vn_sizeof_VkDevice(&device);
1525     cmd_size += vn_sizeof_VkImage(&image);
1526     cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1527     if (pSparseMemoryRequirementCount)
1528         cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1529     if (pSparseMemoryRequirements) {
1530         cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1531         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1532             cmd_size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&pSparseMemoryRequirements[i]);
1533     } else {
1534         cmd_size += vn_sizeof_array_size(0);
1535     }
1536 
1537     return cmd_size;
1538 }
1539 
vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1540 static inline void vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1541 {
1542     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1543 
1544     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1545     vn_encode_VkFlags(enc, &cmd_flags);
1546 
1547     vn_encode_VkDevice(enc, &device);
1548     vn_encode_VkImage(enc, &image);
1549     if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1550         vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1551     if (pSparseMemoryRequirements) {
1552         vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1553         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1554             vn_encode_VkSparseImageMemoryRequirements_partial(enc, &pSparseMemoryRequirements[i]);
1555     } else {
1556         vn_encode_array_size(enc, 0);
1557     }
1558 }
1559 
vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1560 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1561 {
1562     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1563     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1564 
1565     /* skip device */
1566     /* skip image */
1567     cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1568     if (pSparseMemoryRequirementCount)
1569         cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1570     if (pSparseMemoryRequirements) {
1571         cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1572         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1573             cmd_size += vn_sizeof_VkSparseImageMemoryRequirements(&pSparseMemoryRequirements[i]);
1574     } else {
1575         cmd_size += vn_sizeof_array_size(0);
1576     }
1577 
1578     return cmd_size;
1579 }
1580 
vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1581 static inline void vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1582 {
1583     VkCommandTypeEXT command_type;
1584     vn_decode_VkCommandTypeEXT(dec, &command_type);
1585     assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT);
1586 
1587     /* skip device */
1588     /* skip image */
1589     if (vn_decode_simple_pointer(dec)) {
1590         vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1591     } else {
1592         pSparseMemoryRequirementCount = NULL;
1593     }
1594     if (vn_peek_array_size(dec)) {
1595         const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1596         for (uint32_t i = 0; i < iter_count; i++)
1597             vn_decode_VkSparseImageMemoryRequirements(dec, &pSparseMemoryRequirements[i]);
1598     } else {
1599         vn_decode_array_size_unchecked(dec);
1600         pSparseMemoryRequirements = NULL;
1601     }
1602 }
1603 
vn_sizeof_vkCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1604 static inline size_t vn_sizeof_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1605 {
1606     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1607     const VkFlags cmd_flags = 0;
1608     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1609 
1610     cmd_size += vn_sizeof_VkDevice(&device);
1611     cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
1612     if (pCreateInfo)
1613         cmd_size += vn_sizeof_VkImageCreateInfo(pCreateInfo);
1614     cmd_size += vn_sizeof_simple_pointer(pAllocator);
1615     if (pAllocator)
1616         assert(false);
1617     cmd_size += vn_sizeof_simple_pointer(pImage);
1618     if (pImage)
1619         cmd_size += vn_sizeof_VkImage(pImage);
1620 
1621     return cmd_size;
1622 }
1623 
vn_encode_vkCreateImage(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1624 static inline void vn_encode_vkCreateImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1625 {
1626     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1627 
1628     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1629     vn_encode_VkFlags(enc, &cmd_flags);
1630 
1631     vn_encode_VkDevice(enc, &device);
1632     if (vn_encode_simple_pointer(enc, pCreateInfo))
1633         vn_encode_VkImageCreateInfo(enc, pCreateInfo);
1634     if (vn_encode_simple_pointer(enc, pAllocator))
1635         assert(false);
1636     if (vn_encode_simple_pointer(enc, pImage))
1637         vn_encode_VkImage(enc, pImage);
1638 }
1639 
vn_sizeof_vkCreateImage_reply(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1640 static inline size_t vn_sizeof_vkCreateImage_reply(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1641 {
1642     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1643     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1644 
1645     VkResult ret;
1646     cmd_size += vn_sizeof_VkResult(&ret);
1647     /* skip device */
1648     /* skip pCreateInfo */
1649     /* skip pAllocator */
1650     cmd_size += vn_sizeof_simple_pointer(pImage);
1651     if (pImage)
1652         cmd_size += vn_sizeof_VkImage(pImage);
1653 
1654     return cmd_size;
1655 }
1656 
vn_decode_vkCreateImage_reply(struct vn_cs_decoder * dec,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1657 static inline VkResult vn_decode_vkCreateImage_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1658 {
1659     VkCommandTypeEXT command_type;
1660     vn_decode_VkCommandTypeEXT(dec, &command_type);
1661     assert(command_type == VK_COMMAND_TYPE_vkCreateImage_EXT);
1662 
1663     VkResult ret;
1664     vn_decode_VkResult(dec, &ret);
1665     /* skip device */
1666     /* skip pCreateInfo */
1667     /* skip pAllocator */
1668     if (vn_decode_simple_pointer(dec)) {
1669         vn_decode_VkImage(dec, pImage);
1670     } else {
1671         pImage = NULL;
1672     }
1673 
1674     return ret;
1675 }
1676 
vn_sizeof_vkDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1677 static inline size_t vn_sizeof_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1678 {
1679     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1680     const VkFlags cmd_flags = 0;
1681     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1682 
1683     cmd_size += vn_sizeof_VkDevice(&device);
1684     cmd_size += vn_sizeof_VkImage(&image);
1685     cmd_size += vn_sizeof_simple_pointer(pAllocator);
1686     if (pAllocator)
1687         assert(false);
1688 
1689     return cmd_size;
1690 }
1691 
vn_encode_vkDestroyImage(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1692 static inline void vn_encode_vkDestroyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1693 {
1694     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1695 
1696     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1697     vn_encode_VkFlags(enc, &cmd_flags);
1698 
1699     vn_encode_VkDevice(enc, &device);
1700     vn_encode_VkImage(enc, &image);
1701     if (vn_encode_simple_pointer(enc, pAllocator))
1702         assert(false);
1703 }
1704 
vn_sizeof_vkDestroyImage_reply(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1705 static inline size_t vn_sizeof_vkDestroyImage_reply(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1706 {
1707     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1708     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1709 
1710     /* skip device */
1711     /* skip image */
1712     /* skip pAllocator */
1713 
1714     return cmd_size;
1715 }
1716 
vn_decode_vkDestroyImage_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1717 static inline void vn_decode_vkDestroyImage_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1718 {
1719     VkCommandTypeEXT command_type;
1720     vn_decode_VkCommandTypeEXT(dec, &command_type);
1721     assert(command_type == VK_COMMAND_TYPE_vkDestroyImage_EXT);
1722 
1723     /* skip device */
1724     /* skip image */
1725     /* skip pAllocator */
1726 }
1727 
vn_sizeof_vkGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1728 static inline size_t vn_sizeof_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1729 {
1730     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1731     const VkFlags cmd_flags = 0;
1732     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1733 
1734     cmd_size += vn_sizeof_VkDevice(&device);
1735     cmd_size += vn_sizeof_VkImage(&image);
1736     cmd_size += vn_sizeof_simple_pointer(pSubresource);
1737     if (pSubresource)
1738         cmd_size += vn_sizeof_VkImageSubresource(pSubresource);
1739     cmd_size += vn_sizeof_simple_pointer(pLayout);
1740     if (pLayout)
1741         cmd_size += vn_sizeof_VkSubresourceLayout_partial(pLayout);
1742 
1743     return cmd_size;
1744 }
1745 
vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1746 static inline void vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1747 {
1748     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1749 
1750     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1751     vn_encode_VkFlags(enc, &cmd_flags);
1752 
1753     vn_encode_VkDevice(enc, &device);
1754     vn_encode_VkImage(enc, &image);
1755     if (vn_encode_simple_pointer(enc, pSubresource))
1756         vn_encode_VkImageSubresource(enc, pSubresource);
1757     if (vn_encode_simple_pointer(enc, pLayout))
1758         vn_encode_VkSubresourceLayout_partial(enc, pLayout);
1759 }
1760 
vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1761 static inline size_t vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1762 {
1763     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1764     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1765 
1766     /* skip device */
1767     /* skip image */
1768     /* skip pSubresource */
1769     cmd_size += vn_sizeof_simple_pointer(pLayout);
1770     if (pLayout)
1771         cmd_size += vn_sizeof_VkSubresourceLayout(pLayout);
1772 
1773     return cmd_size;
1774 }
1775 
vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1776 static inline void vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1777 {
1778     VkCommandTypeEXT command_type;
1779     vn_decode_VkCommandTypeEXT(dec, &command_type);
1780     assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT);
1781 
1782     /* skip device */
1783     /* skip image */
1784     /* skip pSubresource */
1785     if (vn_decode_simple_pointer(dec)) {
1786         vn_decode_VkSubresourceLayout(dec, pLayout);
1787     } else {
1788         pLayout = NULL;
1789     }
1790 }
1791 
vn_sizeof_vkBindImageMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1792 static inline size_t vn_sizeof_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1793 {
1794     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1795     const VkFlags cmd_flags = 0;
1796     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1797 
1798     cmd_size += vn_sizeof_VkDevice(&device);
1799     cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
1800     if (pBindInfos) {
1801         cmd_size += vn_sizeof_array_size(bindInfoCount);
1802         for (uint32_t i = 0; i < bindInfoCount; i++)
1803             cmd_size += vn_sizeof_VkBindImageMemoryInfo(&pBindInfos[i]);
1804     } else {
1805         cmd_size += vn_sizeof_array_size(0);
1806     }
1807 
1808     return cmd_size;
1809 }
1810 
vn_encode_vkBindImageMemory2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1811 static inline void vn_encode_vkBindImageMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1812 {
1813     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1814 
1815     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1816     vn_encode_VkFlags(enc, &cmd_flags);
1817 
1818     vn_encode_VkDevice(enc, &device);
1819     vn_encode_uint32_t(enc, &bindInfoCount);
1820     if (pBindInfos) {
1821         vn_encode_array_size(enc, bindInfoCount);
1822         for (uint32_t i = 0; i < bindInfoCount; i++)
1823             vn_encode_VkBindImageMemoryInfo(enc, &pBindInfos[i]);
1824     } else {
1825         vn_encode_array_size(enc, 0);
1826     }
1827 }
1828 
vn_sizeof_vkBindImageMemory2_reply(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1829 static inline size_t vn_sizeof_vkBindImageMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1830 {
1831     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1832     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1833 
1834     VkResult ret;
1835     cmd_size += vn_sizeof_VkResult(&ret);
1836     /* skip device */
1837     /* skip bindInfoCount */
1838     /* skip pBindInfos */
1839 
1840     return cmd_size;
1841 }
1842 
vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1843 static inline VkResult vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1844 {
1845     VkCommandTypeEXT command_type;
1846     vn_decode_VkCommandTypeEXT(dec, &command_type);
1847     assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory2_EXT);
1848 
1849     VkResult ret;
1850     vn_decode_VkResult(dec, &ret);
1851     /* skip device */
1852     /* skip bindInfoCount */
1853     /* skip pBindInfos */
1854 
1855     return ret;
1856 }
1857 
vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1858 static inline size_t vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1859 {
1860     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1861     const VkFlags cmd_flags = 0;
1862     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1863 
1864     cmd_size += vn_sizeof_VkDevice(&device);
1865     cmd_size += vn_sizeof_simple_pointer(pInfo);
1866     if (pInfo)
1867         cmd_size += vn_sizeof_VkImageMemoryRequirementsInfo2(pInfo);
1868     cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1869     if (pMemoryRequirements)
1870         cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
1871 
1872     return cmd_size;
1873 }
1874 
vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1875 static inline void vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1876 {
1877     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1878 
1879     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1880     vn_encode_VkFlags(enc, &cmd_flags);
1881 
1882     vn_encode_VkDevice(enc, &device);
1883     if (vn_encode_simple_pointer(enc, pInfo))
1884         vn_encode_VkImageMemoryRequirementsInfo2(enc, pInfo);
1885     if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1886         vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
1887 }
1888 
vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1889 static inline size_t vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1890 {
1891     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1892     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1893 
1894     /* skip device */
1895     /* skip pInfo */
1896     cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1897     if (pMemoryRequirements)
1898         cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
1899 
1900     return cmd_size;
1901 }
1902 
vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1903 static inline void vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1904 {
1905     VkCommandTypeEXT command_type;
1906     vn_decode_VkCommandTypeEXT(dec, &command_type);
1907     assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT);
1908 
1909     /* skip device */
1910     /* skip pInfo */
1911     if (vn_decode_simple_pointer(dec)) {
1912         vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
1913     } else {
1914         pMemoryRequirements = NULL;
1915     }
1916 }
1917 
vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1918 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1919 {
1920     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1921     const VkFlags cmd_flags = 0;
1922     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1923 
1924     cmd_size += vn_sizeof_VkDevice(&device);
1925     cmd_size += vn_sizeof_simple_pointer(pInfo);
1926     if (pInfo)
1927         cmd_size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2(pInfo);
1928     cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1929     if (pSparseMemoryRequirementCount)
1930         cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1931     if (pSparseMemoryRequirements) {
1932         cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1933         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1934             cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
1935     } else {
1936         cmd_size += vn_sizeof_array_size(0);
1937     }
1938 
1939     return cmd_size;
1940 }
1941 
vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1942 static inline void vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1943 {
1944     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1945 
1946     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1947     vn_encode_VkFlags(enc, &cmd_flags);
1948 
1949     vn_encode_VkDevice(enc, &device);
1950     if (vn_encode_simple_pointer(enc, pInfo))
1951         vn_encode_VkImageSparseMemoryRequirementsInfo2(enc, pInfo);
1952     if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1953         vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1954     if (pSparseMemoryRequirements) {
1955         vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1956         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1957             vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
1958     } else {
1959         vn_encode_array_size(enc, 0);
1960     }
1961 }
1962 
vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1963 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1964 {
1965     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1966     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1967 
1968     /* skip device */
1969     /* skip pInfo */
1970     cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1971     if (pSparseMemoryRequirementCount)
1972         cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1973     if (pSparseMemoryRequirements) {
1974         cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1975         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1976             cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
1977     } else {
1978         cmd_size += vn_sizeof_array_size(0);
1979     }
1980 
1981     return cmd_size;
1982 }
1983 
vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1984 static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1985 {
1986     VkCommandTypeEXT command_type;
1987     vn_decode_VkCommandTypeEXT(dec, &command_type);
1988     assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT);
1989 
1990     /* skip device */
1991     /* skip pInfo */
1992     if (vn_decode_simple_pointer(dec)) {
1993         vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1994     } else {
1995         pSparseMemoryRequirementCount = NULL;
1996     }
1997     if (vn_peek_array_size(dec)) {
1998         const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1999         for (uint32_t i = 0; i < iter_count; i++)
2000             vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
2001     } else {
2002         vn_decode_array_size_unchecked(dec);
2003         pSparseMemoryRequirements = NULL;
2004     }
2005 }
2006 
vn_sizeof_vkGetDeviceImageMemoryRequirements(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2007 static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2008 {
2009     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
2010     const VkFlags cmd_flags = 0;
2011     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2012 
2013     cmd_size += vn_sizeof_VkDevice(&device);
2014     cmd_size += vn_sizeof_simple_pointer(pInfo);
2015     if (pInfo)
2016         cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
2017     cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
2018     if (pMemoryRequirements)
2019         cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
2020 
2021     return cmd_size;
2022 }
2023 
vn_encode_vkGetDeviceImageMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2024 static inline void vn_encode_vkGetDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2025 {
2026     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
2027 
2028     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2029     vn_encode_VkFlags(enc, &cmd_flags);
2030 
2031     vn_encode_VkDevice(enc, &device);
2032     if (vn_encode_simple_pointer(enc, pInfo))
2033         vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
2034     if (vn_encode_simple_pointer(enc, pMemoryRequirements))
2035         vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
2036 }
2037 
vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2038 static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2039 {
2040     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
2041     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2042 
2043     /* skip device */
2044     /* skip pInfo */
2045     cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
2046     if (pMemoryRequirements)
2047         cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
2048 
2049     return cmd_size;
2050 }
2051 
vn_decode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2052 static inline void vn_decode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2053 {
2054     VkCommandTypeEXT command_type;
2055     vn_decode_VkCommandTypeEXT(dec, &command_type);
2056     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT);
2057 
2058     /* skip device */
2059     /* skip pInfo */
2060     if (vn_decode_simple_pointer(dec)) {
2061         vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
2062     } else {
2063         pMemoryRequirements = NULL;
2064     }
2065 }
2066 
vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2067 static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2068 {
2069     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
2070     const VkFlags cmd_flags = 0;
2071     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2072 
2073     cmd_size += vn_sizeof_VkDevice(&device);
2074     cmd_size += vn_sizeof_simple_pointer(pInfo);
2075     if (pInfo)
2076         cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
2077     cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
2078     if (pSparseMemoryRequirementCount)
2079         cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
2080     if (pSparseMemoryRequirements) {
2081         cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
2082         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
2083             cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
2084     } else {
2085         cmd_size += vn_sizeof_array_size(0);
2086     }
2087 
2088     return cmd_size;
2089 }
2090 
vn_encode_vkGetDeviceImageSparseMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2091 static inline void vn_encode_vkGetDeviceImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2092 {
2093     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
2094 
2095     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2096     vn_encode_VkFlags(enc, &cmd_flags);
2097 
2098     vn_encode_VkDevice(enc, &device);
2099     if (vn_encode_simple_pointer(enc, pInfo))
2100         vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
2101     if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
2102         vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
2103     if (pSparseMemoryRequirements) {
2104         vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
2105         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
2106             vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
2107     } else {
2108         vn_encode_array_size(enc, 0);
2109     }
2110 }
2111 
vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2112 static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2113 {
2114     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
2115     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2116 
2117     /* skip device */
2118     /* skip pInfo */
2119     cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
2120     if (pSparseMemoryRequirementCount)
2121         cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
2122     if (pSparseMemoryRequirements) {
2123         cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
2124         for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
2125             cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
2126     } else {
2127         cmd_size += vn_sizeof_array_size(0);
2128     }
2129 
2130     return cmd_size;
2131 }
2132 
vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2133 static inline void vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2134 {
2135     VkCommandTypeEXT command_type;
2136     vn_decode_VkCommandTypeEXT(dec, &command_type);
2137     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT);
2138 
2139     /* skip device */
2140     /* skip pInfo */
2141     if (vn_decode_simple_pointer(dec)) {
2142         vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
2143     } else {
2144         pSparseMemoryRequirementCount = NULL;
2145     }
2146     if (vn_peek_array_size(dec)) {
2147         const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
2148         for (uint32_t i = 0; i < iter_count; i++)
2149             vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
2150     } else {
2151         vn_decode_array_size_unchecked(dec);
2152         pSparseMemoryRequirements = NULL;
2153     }
2154 }
2155 
vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2156 static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2157 {
2158     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
2159     const VkFlags cmd_flags = 0;
2160     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2161 
2162     cmd_size += vn_sizeof_VkDevice(&device);
2163     cmd_size += vn_sizeof_VkImage(&image);
2164     cmd_size += vn_sizeof_simple_pointer(pProperties);
2165     if (pProperties)
2166         cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(pProperties);
2167 
2168     return cmd_size;
2169 }
2170 
vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2171 static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2172 {
2173     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
2174 
2175     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2176     vn_encode_VkFlags(enc, &cmd_flags);
2177 
2178     vn_encode_VkDevice(enc, &device);
2179     vn_encode_VkImage(enc, &image);
2180     if (vn_encode_simple_pointer(enc, pProperties))
2181         vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(enc, pProperties);
2182 }
2183 
vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2184 static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2185 {
2186     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
2187     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2188 
2189     VkResult ret;
2190     cmd_size += vn_sizeof_VkResult(&ret);
2191     /* skip device */
2192     /* skip image */
2193     cmd_size += vn_sizeof_simple_pointer(pProperties);
2194     if (pProperties)
2195         cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(pProperties);
2196 
2197     return cmd_size;
2198 }
2199 
vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2200 static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2201 {
2202     VkCommandTypeEXT command_type;
2203     vn_decode_VkCommandTypeEXT(dec, &command_type);
2204     assert(command_type == VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT);
2205 
2206     VkResult ret;
2207     vn_decode_VkResult(dec, &ret);
2208     /* skip device */
2209     /* skip image */
2210     if (vn_decode_simple_pointer(dec)) {
2211         vn_decode_VkImageDrmFormatModifierPropertiesEXT(dec, pProperties);
2212     } else {
2213         pProperties = NULL;
2214     }
2215 
2216     return ret;
2217 }
2218 
vn_sizeof_vkGetImageSubresourceLayout2KHR(VkDevice device,VkImage image,const VkImageSubresource2KHR * pSubresource,VkSubresourceLayout2KHR * pLayout)2219 static inline size_t vn_sizeof_vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
2220 {
2221     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT;
2222     const VkFlags cmd_flags = 0;
2223     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2224 
2225     cmd_size += vn_sizeof_VkDevice(&device);
2226     cmd_size += vn_sizeof_VkImage(&image);
2227     cmd_size += vn_sizeof_simple_pointer(pSubresource);
2228     if (pSubresource)
2229         cmd_size += vn_sizeof_VkImageSubresource2KHR(pSubresource);
2230     cmd_size += vn_sizeof_simple_pointer(pLayout);
2231     if (pLayout)
2232         cmd_size += vn_sizeof_VkSubresourceLayout2KHR_partial(pLayout);
2233 
2234     return cmd_size;
2235 }
2236 
vn_encode_vkGetImageSubresourceLayout2KHR(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkImageSubresource2KHR * pSubresource,VkSubresourceLayout2KHR * pLayout)2237 static inline void vn_encode_vkGetImageSubresourceLayout2KHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
2238 {
2239     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT;
2240 
2241     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2242     vn_encode_VkFlags(enc, &cmd_flags);
2243 
2244     vn_encode_VkDevice(enc, &device);
2245     vn_encode_VkImage(enc, &image);
2246     if (vn_encode_simple_pointer(enc, pSubresource))
2247         vn_encode_VkImageSubresource2KHR(enc, pSubresource);
2248     if (vn_encode_simple_pointer(enc, pLayout))
2249         vn_encode_VkSubresourceLayout2KHR_partial(enc, pLayout);
2250 }
2251 
vn_sizeof_vkGetImageSubresourceLayout2KHR_reply(VkDevice device,VkImage image,const VkImageSubresource2KHR * pSubresource,VkSubresourceLayout2KHR * pLayout)2252 static inline size_t vn_sizeof_vkGetImageSubresourceLayout2KHR_reply(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
2253 {
2254     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT;
2255     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2256 
2257     /* skip device */
2258     /* skip image */
2259     /* skip pSubresource */
2260     cmd_size += vn_sizeof_simple_pointer(pLayout);
2261     if (pLayout)
2262         cmd_size += vn_sizeof_VkSubresourceLayout2KHR(pLayout);
2263 
2264     return cmd_size;
2265 }
2266 
vn_decode_vkGetImageSubresourceLayout2KHR_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,const VkImageSubresource2KHR * pSubresource,VkSubresourceLayout2KHR * pLayout)2267 static inline void vn_decode_vkGetImageSubresourceLayout2KHR_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
2268 {
2269     VkCommandTypeEXT command_type;
2270     vn_decode_VkCommandTypeEXT(dec, &command_type);
2271     assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT);
2272 
2273     /* skip device */
2274     /* skip image */
2275     /* skip pSubresource */
2276     if (vn_decode_simple_pointer(dec)) {
2277         vn_decode_VkSubresourceLayout2KHR(dec, pLayout);
2278     } else {
2279         pLayout = NULL;
2280     }
2281 }
2282 
vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,const VkDeviceImageSubresourceInfoKHR * pInfo,VkSubresourceLayout2KHR * pLayout)2283 static inline size_t vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
2284 {
2285     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_EXT;
2286     const VkFlags cmd_flags = 0;
2287     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2288 
2289     cmd_size += vn_sizeof_VkDevice(&device);
2290     cmd_size += vn_sizeof_simple_pointer(pInfo);
2291     if (pInfo)
2292         cmd_size += vn_sizeof_VkDeviceImageSubresourceInfoKHR(pInfo);
2293     cmd_size += vn_sizeof_simple_pointer(pLayout);
2294     if (pLayout)
2295         cmd_size += vn_sizeof_VkSubresourceLayout2KHR_partial(pLayout);
2296 
2297     return cmd_size;
2298 }
2299 
vn_encode_vkGetDeviceImageSubresourceLayoutKHR(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageSubresourceInfoKHR * pInfo,VkSubresourceLayout2KHR * pLayout)2300 static inline void vn_encode_vkGetDeviceImageSubresourceLayoutKHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
2301 {
2302     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_EXT;
2303 
2304     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2305     vn_encode_VkFlags(enc, &cmd_flags);
2306 
2307     vn_encode_VkDevice(enc, &device);
2308     if (vn_encode_simple_pointer(enc, pInfo))
2309         vn_encode_VkDeviceImageSubresourceInfoKHR(enc, pInfo);
2310     if (vn_encode_simple_pointer(enc, pLayout))
2311         vn_encode_VkSubresourceLayout2KHR_partial(enc, pLayout);
2312 }
2313 
vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR_reply(VkDevice device,const VkDeviceImageSubresourceInfoKHR * pInfo,VkSubresourceLayout2KHR * pLayout)2314 static inline size_t vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR_reply(VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
2315 {
2316     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_EXT;
2317     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2318 
2319     /* skip device */
2320     /* skip pInfo */
2321     cmd_size += vn_sizeof_simple_pointer(pLayout);
2322     if (pLayout)
2323         cmd_size += vn_sizeof_VkSubresourceLayout2KHR(pLayout);
2324 
2325     return cmd_size;
2326 }
2327 
vn_decode_vkGetDeviceImageSubresourceLayoutKHR_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceImageSubresourceInfoKHR * pInfo,VkSubresourceLayout2KHR * pLayout)2328 static inline void vn_decode_vkGetDeviceImageSubresourceLayoutKHR_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
2329 {
2330     VkCommandTypeEXT command_type;
2331     vn_decode_VkCommandTypeEXT(dec, &command_type);
2332     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_EXT);
2333 
2334     /* skip device */
2335     /* skip pInfo */
2336     if (vn_decode_simple_pointer(dec)) {
2337         vn_decode_VkSubresourceLayout2KHR(dec, pLayout);
2338     } else {
2339         pLayout = NULL;
2340     }
2341 }
2342 
vn_submit_vkGetImageMemoryRequirements(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements,struct vn_ring_submit_command * submit)2343 static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_ring_submit_command *submit)
2344 {
2345     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2346     void *cmd_data = local_cmd_data;
2347     size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
2348     if (cmd_size > sizeof(local_cmd_data)) {
2349         cmd_data = malloc(cmd_size);
2350         if (!cmd_data)
2351             cmd_size = 0;
2352     }
2353     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0;
2354 
2355     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2356     if (cmd_size) {
2357         vn_encode_vkGetImageMemoryRequirements(enc, cmd_flags, device, image, pMemoryRequirements);
2358         vn_ring_submit_command(vn_ring, submit);
2359         if (cmd_data != local_cmd_data)
2360             free(cmd_data);
2361     }
2362 }
2363 
vn_submit_vkBindImageMemory(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset,struct vn_ring_submit_command * submit)2364 static inline void vn_submit_vkBindImageMemory(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_ring_submit_command *submit)
2365 {
2366     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2367     void *cmd_data = local_cmd_data;
2368     size_t cmd_size = vn_sizeof_vkBindImageMemory(device, image, memory, memoryOffset);
2369     if (cmd_size > sizeof(local_cmd_data)) {
2370         cmd_data = malloc(cmd_size);
2371         if (!cmd_data)
2372             cmd_size = 0;
2373     }
2374     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0;
2375 
2376     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2377     if (cmd_size) {
2378         vn_encode_vkBindImageMemory(enc, cmd_flags, device, image, memory, memoryOffset);
2379         vn_ring_submit_command(vn_ring, submit);
2380         if (cmd_data != local_cmd_data)
2381             free(cmd_data);
2382     }
2383 }
2384 
vn_submit_vkGetImageSparseMemoryRequirements(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements,struct vn_ring_submit_command * submit)2385 static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_ring_submit_command *submit)
2386 {
2387     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2388     void *cmd_data = local_cmd_data;
2389     size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2390     if (cmd_size > sizeof(local_cmd_data)) {
2391         cmd_data = malloc(cmd_size);
2392         if (!cmd_data)
2393             cmd_size = 0;
2394     }
2395     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2396 
2397     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2398     if (cmd_size) {
2399         vn_encode_vkGetImageSparseMemoryRequirements(enc, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2400         vn_ring_submit_command(vn_ring, submit);
2401         if (cmd_data != local_cmd_data)
2402             free(cmd_data);
2403     }
2404 }
2405 
vn_submit_vkCreateImage(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage,struct vn_ring_submit_command * submit)2406 static inline void vn_submit_vkCreateImage(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_ring_submit_command *submit)
2407 {
2408     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2409     void *cmd_data = local_cmd_data;
2410     size_t cmd_size = vn_sizeof_vkCreateImage(device, pCreateInfo, pAllocator, pImage);
2411     if (cmd_size > sizeof(local_cmd_data)) {
2412         cmd_data = malloc(cmd_size);
2413         if (!cmd_data)
2414             cmd_size = 0;
2415     }
2416     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0;
2417 
2418     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2419     if (cmd_size) {
2420         vn_encode_vkCreateImage(enc, cmd_flags, device, pCreateInfo, pAllocator, pImage);
2421         vn_ring_submit_command(vn_ring, submit);
2422         if (cmd_data != local_cmd_data)
2423             free(cmd_data);
2424     }
2425 }
2426 
vn_submit_vkDestroyImage(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator,struct vn_ring_submit_command * submit)2427 static inline void vn_submit_vkDestroyImage(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_ring_submit_command *submit)
2428 {
2429     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2430     void *cmd_data = local_cmd_data;
2431     size_t cmd_size = vn_sizeof_vkDestroyImage(device, image, pAllocator);
2432     if (cmd_size > sizeof(local_cmd_data)) {
2433         cmd_data = malloc(cmd_size);
2434         if (!cmd_data)
2435             cmd_size = 0;
2436     }
2437     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0;
2438 
2439     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2440     if (cmd_size) {
2441         vn_encode_vkDestroyImage(enc, cmd_flags, device, image, pAllocator);
2442         vn_ring_submit_command(vn_ring, submit);
2443         if (cmd_data != local_cmd_data)
2444             free(cmd_data);
2445     }
2446 }
2447 
vn_submit_vkGetImageSubresourceLayout(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout,struct vn_ring_submit_command * submit)2448 static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_ring_submit_command *submit)
2449 {
2450     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2451     void *cmd_data = local_cmd_data;
2452     size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
2453     if (cmd_size > sizeof(local_cmd_data)) {
2454         cmd_data = malloc(cmd_size);
2455         if (!cmd_data)
2456             cmd_size = 0;
2457     }
2458     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0;
2459 
2460     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2461     if (cmd_size) {
2462         vn_encode_vkGetImageSubresourceLayout(enc, cmd_flags, device, image, pSubresource, pLayout);
2463         vn_ring_submit_command(vn_ring, submit);
2464         if (cmd_data != local_cmd_data)
2465             free(cmd_data);
2466     }
2467 }
2468 
vn_submit_vkBindImageMemory2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos,struct vn_ring_submit_command * submit)2469 static inline void vn_submit_vkBindImageMemory2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_ring_submit_command *submit)
2470 {
2471     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2472     void *cmd_data = local_cmd_data;
2473     size_t cmd_size = vn_sizeof_vkBindImageMemory2(device, bindInfoCount, pBindInfos);
2474     if (cmd_size > sizeof(local_cmd_data)) {
2475         cmd_data = malloc(cmd_size);
2476         if (!cmd_data)
2477             cmd_size = 0;
2478     }
2479     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
2480 
2481     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2482     if (cmd_size) {
2483         vn_encode_vkBindImageMemory2(enc, cmd_flags, device, bindInfoCount, pBindInfos);
2484         vn_ring_submit_command(vn_ring, submit);
2485         if (cmd_data != local_cmd_data)
2486             free(cmd_data);
2487     }
2488 }
2489 
vn_submit_vkGetImageMemoryRequirements2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements,struct vn_ring_submit_command * submit)2490 static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_ring_submit_command *submit)
2491 {
2492     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2493     void *cmd_data = local_cmd_data;
2494     size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
2495     if (cmd_size > sizeof(local_cmd_data)) {
2496         cmd_data = malloc(cmd_size);
2497         if (!cmd_data)
2498             cmd_size = 0;
2499     }
2500     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
2501 
2502     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2503     if (cmd_size) {
2504         vn_encode_vkGetImageMemoryRequirements2(enc, cmd_flags, device, pInfo, pMemoryRequirements);
2505         vn_ring_submit_command(vn_ring, submit);
2506         if (cmd_data != local_cmd_data)
2507             free(cmd_data);
2508     }
2509 }
2510 
vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements,struct vn_ring_submit_command * submit)2511 static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_ring_submit_command *submit)
2512 {
2513     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2514     void *cmd_data = local_cmd_data;
2515     size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2516     if (cmd_size > sizeof(local_cmd_data)) {
2517         cmd_data = malloc(cmd_size);
2518         if (!cmd_data)
2519             cmd_size = 0;
2520     }
2521     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2522 
2523     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2524     if (cmd_size) {
2525         vn_encode_vkGetImageSparseMemoryRequirements2(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2526         vn_ring_submit_command(vn_ring, submit);
2527         if (cmd_data != local_cmd_data)
2528             free(cmd_data);
2529     }
2530 }
2531 
vn_submit_vkGetDeviceImageMemoryRequirements(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements,struct vn_ring_submit_command * submit)2532 static inline void vn_submit_vkGetDeviceImageMemoryRequirements(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_ring_submit_command *submit)
2533 {
2534     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2535     void *cmd_data = local_cmd_data;
2536     size_t cmd_size = vn_sizeof_vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
2537     if (cmd_size > sizeof(local_cmd_data)) {
2538         cmd_data = malloc(cmd_size);
2539         if (!cmd_data)
2540             cmd_size = 0;
2541     }
2542     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(device, pInfo, pMemoryRequirements) : 0;
2543 
2544     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2545     if (cmd_size) {
2546         vn_encode_vkGetDeviceImageMemoryRequirements(enc, cmd_flags, device, pInfo, pMemoryRequirements);
2547         vn_ring_submit_command(vn_ring, submit);
2548         if (cmd_data != local_cmd_data)
2549             free(cmd_data);
2550     }
2551 }
2552 
vn_submit_vkGetDeviceImageSparseMemoryRequirements(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements,struct vn_ring_submit_command * submit)2553 static inline void vn_submit_vkGetDeviceImageSparseMemoryRequirements(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_ring_submit_command *submit)
2554 {
2555     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2556     void *cmd_data = local_cmd_data;
2557     size_t cmd_size = vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2558     if (cmd_size > sizeof(local_cmd_data)) {
2559         cmd_data = malloc(cmd_size);
2560         if (!cmd_data)
2561             cmd_size = 0;
2562     }
2563     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2564 
2565     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2566     if (cmd_size) {
2567         vn_encode_vkGetDeviceImageSparseMemoryRequirements(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2568         vn_ring_submit_command(vn_ring, submit);
2569         if (cmd_data != local_cmd_data)
2570             free(cmd_data);
2571     }
2572 }
2573 
vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties,struct vn_ring_submit_command * submit)2574 static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_ring_submit_command *submit)
2575 {
2576     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2577     void *cmd_data = local_cmd_data;
2578     size_t cmd_size = vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
2579     if (cmd_size > sizeof(local_cmd_data)) {
2580         cmd_data = malloc(cmd_size);
2581         if (!cmd_data)
2582             cmd_size = 0;
2583     }
2584     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0;
2585 
2586     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2587     if (cmd_size) {
2588         vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(enc, cmd_flags, device, image, pProperties);
2589         vn_ring_submit_command(vn_ring, submit);
2590         if (cmd_data != local_cmd_data)
2591             free(cmd_data);
2592     }
2593 }
2594 
vn_submit_vkGetImageSubresourceLayout2KHR(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkImageSubresource2KHR * pSubresource,VkSubresourceLayout2KHR * pLayout,struct vn_ring_submit_command * submit)2595 static inline void vn_submit_vkGetImageSubresourceLayout2KHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout, struct vn_ring_submit_command *submit)
2596 {
2597     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2598     void *cmd_data = local_cmd_data;
2599     size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout);
2600     if (cmd_size > sizeof(local_cmd_data)) {
2601         cmd_data = malloc(cmd_size);
2602         if (!cmd_data)
2603             cmd_size = 0;
2604     }
2605     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout2KHR_reply(device, image, pSubresource, pLayout) : 0;
2606 
2607     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2608     if (cmd_size) {
2609         vn_encode_vkGetImageSubresourceLayout2KHR(enc, cmd_flags, device, image, pSubresource, pLayout);
2610         vn_ring_submit_command(vn_ring, submit);
2611         if (cmd_data != local_cmd_data)
2612             free(cmd_data);
2613     }
2614 }
2615 
vn_submit_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageSubresourceInfoKHR * pInfo,VkSubresourceLayout2KHR * pLayout,struct vn_ring_submit_command * submit)2616 static inline void vn_submit_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout, struct vn_ring_submit_command *submit)
2617 {
2618     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2619     void *cmd_data = local_cmd_data;
2620     size_t cmd_size = vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout);
2621     if (cmd_size > sizeof(local_cmd_data)) {
2622         cmd_data = malloc(cmd_size);
2623         if (!cmd_data)
2624             cmd_size = 0;
2625     }
2626     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR_reply(device, pInfo, pLayout) : 0;
2627 
2628     struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2629     if (cmd_size) {
2630         vn_encode_vkGetDeviceImageSubresourceLayoutKHR(enc, cmd_flags, device, pInfo, pLayout);
2631         vn_ring_submit_command(vn_ring, submit);
2632         if (cmd_data != local_cmd_data)
2633             free(cmd_data);
2634     }
2635 }
2636 
vn_call_vkGetImageMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)2637 static inline void vn_call_vkGetImageMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
2638 {
2639     VN_TRACE_FUNC();
2640 
2641     struct vn_ring_submit_command submit;
2642     vn_submit_vkGetImageMemoryRequirements(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit);
2643     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2644     if (dec) {
2645         vn_decode_vkGetImageMemoryRequirements_reply(dec, device, image, pMemoryRequirements);
2646         vn_ring_free_command_reply(vn_ring, &submit);
2647     }
2648 }
2649 
vn_async_vkGetImageMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)2650 static inline void vn_async_vkGetImageMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
2651 {
2652     struct vn_ring_submit_command submit;
2653     vn_submit_vkGetImageMemoryRequirements(vn_ring, 0, device, image, pMemoryRequirements, &submit);
2654 }
2655 
vn_call_vkBindImageMemory(struct vn_ring * vn_ring,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)2656 static inline VkResult vn_call_vkBindImageMemory(struct vn_ring *vn_ring, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
2657 {
2658     VN_TRACE_FUNC();
2659 
2660     struct vn_ring_submit_command submit;
2661     vn_submit_vkBindImageMemory(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit);
2662     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2663     if (dec) {
2664         const VkResult ret = vn_decode_vkBindImageMemory_reply(dec, device, image, memory, memoryOffset);
2665         vn_ring_free_command_reply(vn_ring, &submit);
2666         return ret;
2667     } else {
2668         return VK_ERROR_OUT_OF_HOST_MEMORY;
2669     }
2670 }
2671 
vn_async_vkBindImageMemory(struct vn_ring * vn_ring,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)2672 static inline void vn_async_vkBindImageMemory(struct vn_ring *vn_ring, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
2673 {
2674     struct vn_ring_submit_command submit;
2675     vn_submit_vkBindImageMemory(vn_ring, 0, device, image, memory, memoryOffset, &submit);
2676 }
2677 
vn_call_vkGetImageSparseMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)2678 static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
2679 {
2680     VN_TRACE_FUNC();
2681 
2682     struct vn_ring_submit_command submit;
2683     vn_submit_vkGetImageSparseMemoryRequirements(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2684     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2685     if (dec) {
2686         vn_decode_vkGetImageSparseMemoryRequirements_reply(dec, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2687         vn_ring_free_command_reply(vn_ring, &submit);
2688     }
2689 }
2690 
vn_async_vkGetImageSparseMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)2691 static inline void vn_async_vkGetImageSparseMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
2692 {
2693     struct vn_ring_submit_command submit;
2694     vn_submit_vkGetImageSparseMemoryRequirements(vn_ring, 0, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2695 }
2696 
vn_call_vkCreateImage(struct vn_ring * vn_ring,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)2697 static inline VkResult vn_call_vkCreateImage(struct vn_ring *vn_ring, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
2698 {
2699     VN_TRACE_FUNC();
2700 
2701     struct vn_ring_submit_command submit;
2702     vn_submit_vkCreateImage(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit);
2703     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2704     if (dec) {
2705         const VkResult ret = vn_decode_vkCreateImage_reply(dec, device, pCreateInfo, pAllocator, pImage);
2706         vn_ring_free_command_reply(vn_ring, &submit);
2707         return ret;
2708     } else {
2709         return VK_ERROR_OUT_OF_HOST_MEMORY;
2710     }
2711 }
2712 
vn_async_vkCreateImage(struct vn_ring * vn_ring,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)2713 static inline void vn_async_vkCreateImage(struct vn_ring *vn_ring, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
2714 {
2715     struct vn_ring_submit_command submit;
2716     vn_submit_vkCreateImage(vn_ring, 0, device, pCreateInfo, pAllocator, pImage, &submit);
2717 }
2718 
vn_call_vkDestroyImage(struct vn_ring * vn_ring,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)2719 static inline void vn_call_vkDestroyImage(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
2720 {
2721     VN_TRACE_FUNC();
2722 
2723     struct vn_ring_submit_command submit;
2724     vn_submit_vkDestroyImage(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit);
2725     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2726     if (dec) {
2727         vn_decode_vkDestroyImage_reply(dec, device, image, pAllocator);
2728         vn_ring_free_command_reply(vn_ring, &submit);
2729     }
2730 }
2731 
vn_async_vkDestroyImage(struct vn_ring * vn_ring,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)2732 static inline void vn_async_vkDestroyImage(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
2733 {
2734     struct vn_ring_submit_command submit;
2735     vn_submit_vkDestroyImage(vn_ring, 0, device, image, pAllocator, &submit);
2736 }
2737 
vn_call_vkGetImageSubresourceLayout(struct vn_ring * vn_ring,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)2738 static inline void vn_call_vkGetImageSubresourceLayout(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
2739 {
2740     VN_TRACE_FUNC();
2741 
2742     struct vn_ring_submit_command submit;
2743     vn_submit_vkGetImageSubresourceLayout(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
2744     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2745     if (dec) {
2746         vn_decode_vkGetImageSubresourceLayout_reply(dec, device, image, pSubresource, pLayout);
2747         vn_ring_free_command_reply(vn_ring, &submit);
2748     }
2749 }
2750 
vn_async_vkGetImageSubresourceLayout(struct vn_ring * vn_ring,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)2751 static inline void vn_async_vkGetImageSubresourceLayout(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
2752 {
2753     struct vn_ring_submit_command submit;
2754     vn_submit_vkGetImageSubresourceLayout(vn_ring, 0, device, image, pSubresource, pLayout, &submit);
2755 }
2756 
vn_call_vkBindImageMemory2(struct vn_ring * vn_ring,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)2757 static inline VkResult vn_call_vkBindImageMemory2(struct vn_ring *vn_ring, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
2758 {
2759     VN_TRACE_FUNC();
2760 
2761     struct vn_ring_submit_command submit;
2762     vn_submit_vkBindImageMemory2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
2763     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2764     if (dec) {
2765         const VkResult ret = vn_decode_vkBindImageMemory2_reply(dec, device, bindInfoCount, pBindInfos);
2766         vn_ring_free_command_reply(vn_ring, &submit);
2767         return ret;
2768     } else {
2769         return VK_ERROR_OUT_OF_HOST_MEMORY;
2770     }
2771 }
2772 
vn_async_vkBindImageMemory2(struct vn_ring * vn_ring,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)2773 static inline void vn_async_vkBindImageMemory2(struct vn_ring *vn_ring, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
2774 {
2775     struct vn_ring_submit_command submit;
2776     vn_submit_vkBindImageMemory2(vn_ring, 0, device, bindInfoCount, pBindInfos, &submit);
2777 }
2778 
vn_call_vkGetImageMemoryRequirements2(struct vn_ring * vn_ring,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2779 static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_ring *vn_ring, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2780 {
2781     VN_TRACE_FUNC();
2782 
2783     struct vn_ring_submit_command submit;
2784     vn_submit_vkGetImageMemoryRequirements2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
2785     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2786     if (dec) {
2787         vn_decode_vkGetImageMemoryRequirements2_reply(dec, device, pInfo, pMemoryRequirements);
2788         vn_ring_free_command_reply(vn_ring, &submit);
2789     }
2790 }
2791 
vn_async_vkGetImageMemoryRequirements2(struct vn_ring * vn_ring,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2792 static inline void vn_async_vkGetImageMemoryRequirements2(struct vn_ring *vn_ring, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2793 {
2794     struct vn_ring_submit_command submit;
2795     vn_submit_vkGetImageMemoryRequirements2(vn_ring, 0, device, pInfo, pMemoryRequirements, &submit);
2796 }
2797 
vn_call_vkGetImageSparseMemoryRequirements2(struct vn_ring * vn_ring,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2798 static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_ring *vn_ring, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2799 {
2800     VN_TRACE_FUNC();
2801 
2802     struct vn_ring_submit_command submit;
2803     vn_submit_vkGetImageSparseMemoryRequirements2(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2804     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2805     if (dec) {
2806         vn_decode_vkGetImageSparseMemoryRequirements2_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2807         vn_ring_free_command_reply(vn_ring, &submit);
2808     }
2809 }
2810 
vn_async_vkGetImageSparseMemoryRequirements2(struct vn_ring * vn_ring,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2811 static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_ring *vn_ring, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2812 {
2813     struct vn_ring_submit_command submit;
2814     vn_submit_vkGetImageSparseMemoryRequirements2(vn_ring, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2815 }
2816 
vn_call_vkGetDeviceImageMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2817 static inline void vn_call_vkGetDeviceImageMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2818 {
2819     VN_TRACE_FUNC();
2820 
2821     struct vn_ring_submit_command submit;
2822     vn_submit_vkGetDeviceImageMemoryRequirements(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
2823     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2824     if (dec) {
2825         vn_decode_vkGetDeviceImageMemoryRequirements_reply(dec, device, pInfo, pMemoryRequirements);
2826         vn_ring_free_command_reply(vn_ring, &submit);
2827     }
2828 }
2829 
vn_async_vkGetDeviceImageMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2830 static inline void vn_async_vkGetDeviceImageMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2831 {
2832     struct vn_ring_submit_command submit;
2833     vn_submit_vkGetDeviceImageMemoryRequirements(vn_ring, 0, device, pInfo, pMemoryRequirements, &submit);
2834 }
2835 
vn_call_vkGetDeviceImageSparseMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2836 static inline void vn_call_vkGetDeviceImageSparseMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2837 {
2838     VN_TRACE_FUNC();
2839 
2840     struct vn_ring_submit_command submit;
2841     vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2842     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2843     if (dec) {
2844         vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2845         vn_ring_free_command_reply(vn_ring, &submit);
2846     }
2847 }
2848 
vn_async_vkGetDeviceImageSparseMemoryRequirements(struct vn_ring * vn_ring,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2849 static inline void vn_async_vkGetDeviceImageSparseMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2850 {
2851     struct vn_ring_submit_command submit;
2852     vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_ring, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2853 }
2854 
vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_ring * vn_ring,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2855 static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_ring *vn_ring, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2856 {
2857     VN_TRACE_FUNC();
2858 
2859     struct vn_ring_submit_command submit;
2860     vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit);
2861     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2862     if (dec) {
2863         const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(dec, device, image, pProperties);
2864         vn_ring_free_command_reply(vn_ring, &submit);
2865         return ret;
2866     } else {
2867         return VK_ERROR_OUT_OF_HOST_MEMORY;
2868     }
2869 }
2870 
vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_ring * vn_ring,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2871 static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_ring *vn_ring, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2872 {
2873     struct vn_ring_submit_command submit;
2874     vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_ring, 0, device, image, pProperties, &submit);
2875 }
2876 
vn_call_vkGetImageSubresourceLayout2KHR(struct vn_ring * vn_ring,VkDevice device,VkImage image,const VkImageSubresource2KHR * pSubresource,VkSubresourceLayout2KHR * pLayout)2877 static inline void vn_call_vkGetImageSubresourceLayout2KHR(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
2878 {
2879     VN_TRACE_FUNC();
2880 
2881     struct vn_ring_submit_command submit;
2882     vn_submit_vkGetImageSubresourceLayout2KHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
2883     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2884     if (dec) {
2885         vn_decode_vkGetImageSubresourceLayout2KHR_reply(dec, device, image, pSubresource, pLayout);
2886         vn_ring_free_command_reply(vn_ring, &submit);
2887     }
2888 }
2889 
vn_async_vkGetImageSubresourceLayout2KHR(struct vn_ring * vn_ring,VkDevice device,VkImage image,const VkImageSubresource2KHR * pSubresource,VkSubresourceLayout2KHR * pLayout)2890 static inline void vn_async_vkGetImageSubresourceLayout2KHR(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
2891 {
2892     struct vn_ring_submit_command submit;
2893     vn_submit_vkGetImageSubresourceLayout2KHR(vn_ring, 0, device, image, pSubresource, pLayout, &submit);
2894 }
2895 
vn_call_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring * vn_ring,VkDevice device,const VkDeviceImageSubresourceInfoKHR * pInfo,VkSubresourceLayout2KHR * pLayout)2896 static inline void vn_call_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
2897 {
2898     VN_TRACE_FUNC();
2899 
2900     struct vn_ring_submit_command submit;
2901     vn_submit_vkGetDeviceImageSubresourceLayoutKHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pLayout, &submit);
2902     struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2903     if (dec) {
2904         vn_decode_vkGetDeviceImageSubresourceLayoutKHR_reply(dec, device, pInfo, pLayout);
2905         vn_ring_free_command_reply(vn_ring, &submit);
2906     }
2907 }
2908 
vn_async_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring * vn_ring,VkDevice device,const VkDeviceImageSubresourceInfoKHR * pInfo,VkSubresourceLayout2KHR * pLayout)2909 static inline void vn_async_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
2910 {
2911     struct vn_ring_submit_command submit;
2912     vn_submit_vkGetDeviceImageSubresourceLayoutKHR(vn_ring, 0, device, pInfo, pLayout, &submit);
2913 }
2914 
2915 #endif /* VN_PROTOCOL_DRIVER_IMAGE_H */
2916