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