1 /* This file is generated by venus-protocol. See vn_protocol_driver.h. */
2
3 /*
4 * Copyright 2020 Google LLC
5 * SPDX-License-Identifier: MIT
6 */
7
8 #ifndef VN_PROTOCOL_DRIVER_IMAGE_H
9 #define VN_PROTOCOL_DRIVER_IMAGE_H
10
11 #include "vn_instance.h"
12 #include "vn_protocol_driver_structs.h"
13
14 /* struct VkSparseImageMemoryRequirements */
15
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->pQueueFamilyIndices) {
374 size += vn_sizeof_array_size(val->queueFamilyIndexCount);
375 size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
376 } else {
377 size += vn_sizeof_array_size(0);
378 }
379 size += vn_sizeof_VkImageLayout(&val->initialLayout);
380 return size;
381 }
382
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->pQueueFamilyIndices) {
462 vn_encode_array_size(enc, val->queueFamilyIndexCount);
463 vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
464 } else {
465 vn_encode_array_size(enc, 0);
466 }
467 vn_encode_VkImageLayout(enc, &val->initialLayout);
468 }
469
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
vn_sizeof_vkGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1181 static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1182 {
1183 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1184 const VkFlags cmd_flags = 0;
1185 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1186
1187 cmd_size += vn_sizeof_VkDevice(&device);
1188 cmd_size += vn_sizeof_VkImage(&image);
1189 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1190 if (pMemoryRequirements)
1191 cmd_size += vn_sizeof_VkMemoryRequirements_partial(pMemoryRequirements);
1192
1193 return cmd_size;
1194 }
1195
vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1196 static inline void vn_encode_vkGetImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1197 {
1198 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1199
1200 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1201 vn_encode_VkFlags(enc, &cmd_flags);
1202
1203 vn_encode_VkDevice(enc, &device);
1204 vn_encode_VkImage(enc, &image);
1205 if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1206 vn_encode_VkMemoryRequirements_partial(enc, pMemoryRequirements);
1207 }
1208
vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1209 static inline size_t vn_sizeof_vkGetImageMemoryRequirements_reply(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1210 {
1211 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
1212 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1213
1214 /* skip device */
1215 /* skip image */
1216 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1217 if (pMemoryRequirements)
1218 cmd_size += vn_sizeof_VkMemoryRequirements(pMemoryRequirements);
1219
1220 return cmd_size;
1221 }
1222
vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)1223 static inline void vn_decode_vkGetImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
1224 {
1225 VkCommandTypeEXT command_type;
1226 vn_decode_VkCommandTypeEXT(dec, &command_type);
1227 assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT);
1228
1229 /* skip device */
1230 /* skip image */
1231 if (vn_decode_simple_pointer(dec)) {
1232 vn_decode_VkMemoryRequirements(dec, pMemoryRequirements);
1233 } else {
1234 pMemoryRequirements = NULL;
1235 }
1236 }
1237
vn_sizeof_vkBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1238 static inline size_t vn_sizeof_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1239 {
1240 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1241 const VkFlags cmd_flags = 0;
1242 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1243
1244 cmd_size += vn_sizeof_VkDevice(&device);
1245 cmd_size += vn_sizeof_VkImage(&image);
1246 cmd_size += vn_sizeof_VkDeviceMemory(&memory);
1247 cmd_size += vn_sizeof_VkDeviceSize(&memoryOffset);
1248
1249 return cmd_size;
1250 }
1251
vn_encode_vkBindImageMemory(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1252 static inline void vn_encode_vkBindImageMemory(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1253 {
1254 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1255
1256 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1257 vn_encode_VkFlags(enc, &cmd_flags);
1258
1259 vn_encode_VkDevice(enc, &device);
1260 vn_encode_VkImage(enc, &image);
1261 vn_encode_VkDeviceMemory(enc, &memory);
1262 vn_encode_VkDeviceSize(enc, &memoryOffset);
1263 }
1264
vn_sizeof_vkBindImageMemory_reply(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1265 static inline size_t vn_sizeof_vkBindImageMemory_reply(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1266 {
1267 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory_EXT;
1268 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1269
1270 VkResult ret;
1271 cmd_size += vn_sizeof_VkResult(&ret);
1272 /* skip device */
1273 /* skip image */
1274 /* skip memory */
1275 /* skip memoryOffset */
1276
1277 return cmd_size;
1278 }
1279
vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)1280 static inline VkResult vn_decode_vkBindImageMemory_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1281 {
1282 VkCommandTypeEXT command_type;
1283 vn_decode_VkCommandTypeEXT(dec, &command_type);
1284 assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory_EXT);
1285
1286 VkResult ret;
1287 vn_decode_VkResult(dec, &ret);
1288 /* skip device */
1289 /* skip image */
1290 /* skip memory */
1291 /* skip memoryOffset */
1292
1293 return ret;
1294 }
1295
vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1296 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1297 {
1298 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1299 const VkFlags cmd_flags = 0;
1300 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1301
1302 cmd_size += vn_sizeof_VkDevice(&device);
1303 cmd_size += vn_sizeof_VkImage(&image);
1304 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1305 if (pSparseMemoryRequirementCount)
1306 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1307 if (pSparseMemoryRequirements) {
1308 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1309 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1310 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements_partial(&pSparseMemoryRequirements[i]);
1311 } else {
1312 cmd_size += vn_sizeof_array_size(0);
1313 }
1314
1315 return cmd_size;
1316 }
1317
vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1318 static inline void vn_encode_vkGetImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1319 {
1320 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1321
1322 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1323 vn_encode_VkFlags(enc, &cmd_flags);
1324
1325 vn_encode_VkDevice(enc, &device);
1326 vn_encode_VkImage(enc, &image);
1327 if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1328 vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1329 if (pSparseMemoryRequirements) {
1330 vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1331 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1332 vn_encode_VkSparseImageMemoryRequirements_partial(enc, &pSparseMemoryRequirements[i]);
1333 } else {
1334 vn_encode_array_size(enc, 0);
1335 }
1336 }
1337
vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1338 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements_reply(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1339 {
1340 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT;
1341 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1342
1343 /* skip device */
1344 /* skip image */
1345 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1346 if (pSparseMemoryRequirementCount)
1347 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1348 if (pSparseMemoryRequirements) {
1349 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1350 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1351 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements(&pSparseMemoryRequirements[i]);
1352 } else {
1353 cmd_size += vn_sizeof_array_size(0);
1354 }
1355
1356 return cmd_size;
1357 }
1358
vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)1359 static inline void vn_decode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
1360 {
1361 VkCommandTypeEXT command_type;
1362 vn_decode_VkCommandTypeEXT(dec, &command_type);
1363 assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT);
1364
1365 /* skip device */
1366 /* skip image */
1367 if (vn_decode_simple_pointer(dec)) {
1368 vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1369 } else {
1370 pSparseMemoryRequirementCount = NULL;
1371 }
1372 if (vn_peek_array_size(dec)) {
1373 const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1374 for (uint32_t i = 0; i < iter_count; i++)
1375 vn_decode_VkSparseImageMemoryRequirements(dec, &pSparseMemoryRequirements[i]);
1376 } else {
1377 vn_decode_array_size_unchecked(dec);
1378 pSparseMemoryRequirements = NULL;
1379 }
1380 }
1381
vn_sizeof_vkCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1382 static inline size_t vn_sizeof_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1383 {
1384 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1385 const VkFlags cmd_flags = 0;
1386 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1387
1388 cmd_size += vn_sizeof_VkDevice(&device);
1389 cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
1390 if (pCreateInfo)
1391 cmd_size += vn_sizeof_VkImageCreateInfo(pCreateInfo);
1392 cmd_size += vn_sizeof_simple_pointer(pAllocator);
1393 if (pAllocator)
1394 assert(false);
1395 cmd_size += vn_sizeof_simple_pointer(pImage);
1396 if (pImage)
1397 cmd_size += vn_sizeof_VkImage(pImage);
1398
1399 return cmd_size;
1400 }
1401
vn_encode_vkCreateImage(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1402 static inline void vn_encode_vkCreateImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1403 {
1404 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1405
1406 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1407 vn_encode_VkFlags(enc, &cmd_flags);
1408
1409 vn_encode_VkDevice(enc, &device);
1410 if (vn_encode_simple_pointer(enc, pCreateInfo))
1411 vn_encode_VkImageCreateInfo(enc, pCreateInfo);
1412 if (vn_encode_simple_pointer(enc, pAllocator))
1413 assert(false);
1414 if (vn_encode_simple_pointer(enc, pImage))
1415 vn_encode_VkImage(enc, pImage);
1416 }
1417
vn_sizeof_vkCreateImage_reply(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1418 static inline size_t vn_sizeof_vkCreateImage_reply(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1419 {
1420 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImage_EXT;
1421 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1422
1423 VkResult ret;
1424 cmd_size += vn_sizeof_VkResult(&ret);
1425 /* skip device */
1426 /* skip pCreateInfo */
1427 /* skip pAllocator */
1428 cmd_size += vn_sizeof_simple_pointer(pImage);
1429 if (pImage)
1430 cmd_size += vn_sizeof_VkImage(pImage);
1431
1432 return cmd_size;
1433 }
1434
vn_decode_vkCreateImage_reply(struct vn_cs_decoder * dec,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1435 static inline VkResult vn_decode_vkCreateImage_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
1436 {
1437 VkCommandTypeEXT command_type;
1438 vn_decode_VkCommandTypeEXT(dec, &command_type);
1439 assert(command_type == VK_COMMAND_TYPE_vkCreateImage_EXT);
1440
1441 VkResult ret;
1442 vn_decode_VkResult(dec, &ret);
1443 /* skip device */
1444 /* skip pCreateInfo */
1445 /* skip pAllocator */
1446 if (vn_decode_simple_pointer(dec)) {
1447 vn_decode_VkImage(dec, pImage);
1448 } else {
1449 pImage = NULL;
1450 }
1451
1452 return ret;
1453 }
1454
vn_sizeof_vkDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1455 static inline size_t vn_sizeof_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1456 {
1457 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1458 const VkFlags cmd_flags = 0;
1459 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1460
1461 cmd_size += vn_sizeof_VkDevice(&device);
1462 cmd_size += vn_sizeof_VkImage(&image);
1463 cmd_size += vn_sizeof_simple_pointer(pAllocator);
1464 if (pAllocator)
1465 assert(false);
1466
1467 return cmd_size;
1468 }
1469
vn_encode_vkDestroyImage(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1470 static inline void vn_encode_vkDestroyImage(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1471 {
1472 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1473
1474 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1475 vn_encode_VkFlags(enc, &cmd_flags);
1476
1477 vn_encode_VkDevice(enc, &device);
1478 vn_encode_VkImage(enc, &image);
1479 if (vn_encode_simple_pointer(enc, pAllocator))
1480 assert(false);
1481 }
1482
vn_sizeof_vkDestroyImage_reply(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1483 static inline size_t vn_sizeof_vkDestroyImage_reply(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1484 {
1485 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImage_EXT;
1486 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1487
1488 /* skip device */
1489 /* skip image */
1490 /* skip pAllocator */
1491
1492 return cmd_size;
1493 }
1494
vn_decode_vkDestroyImage_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1495 static inline void vn_decode_vkDestroyImage_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
1496 {
1497 VkCommandTypeEXT command_type;
1498 vn_decode_VkCommandTypeEXT(dec, &command_type);
1499 assert(command_type == VK_COMMAND_TYPE_vkDestroyImage_EXT);
1500
1501 /* skip device */
1502 /* skip image */
1503 /* skip pAllocator */
1504 }
1505
vn_sizeof_vkGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1506 static inline size_t vn_sizeof_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1507 {
1508 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1509 const VkFlags cmd_flags = 0;
1510 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1511
1512 cmd_size += vn_sizeof_VkDevice(&device);
1513 cmd_size += vn_sizeof_VkImage(&image);
1514 cmd_size += vn_sizeof_simple_pointer(pSubresource);
1515 if (pSubresource)
1516 cmd_size += vn_sizeof_VkImageSubresource(pSubresource);
1517 cmd_size += vn_sizeof_simple_pointer(pLayout);
1518 if (pLayout)
1519 cmd_size += vn_sizeof_VkSubresourceLayout_partial(pLayout);
1520
1521 return cmd_size;
1522 }
1523
vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1524 static inline void vn_encode_vkGetImageSubresourceLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1525 {
1526 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1527
1528 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1529 vn_encode_VkFlags(enc, &cmd_flags);
1530
1531 vn_encode_VkDevice(enc, &device);
1532 vn_encode_VkImage(enc, &image);
1533 if (vn_encode_simple_pointer(enc, pSubresource))
1534 vn_encode_VkImageSubresource(enc, pSubresource);
1535 if (vn_encode_simple_pointer(enc, pLayout))
1536 vn_encode_VkSubresourceLayout_partial(enc, pLayout);
1537 }
1538
vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1539 static inline size_t vn_sizeof_vkGetImageSubresourceLayout_reply(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1540 {
1541 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT;
1542 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1543
1544 /* skip device */
1545 /* skip image */
1546 /* skip pSubresource */
1547 cmd_size += vn_sizeof_simple_pointer(pLayout);
1548 if (pLayout)
1549 cmd_size += vn_sizeof_VkSubresourceLayout(pLayout);
1550
1551 return cmd_size;
1552 }
1553
vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1554 static inline void vn_decode_vkGetImageSubresourceLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
1555 {
1556 VkCommandTypeEXT command_type;
1557 vn_decode_VkCommandTypeEXT(dec, &command_type);
1558 assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT);
1559
1560 /* skip device */
1561 /* skip image */
1562 /* skip pSubresource */
1563 if (vn_decode_simple_pointer(dec)) {
1564 vn_decode_VkSubresourceLayout(dec, pLayout);
1565 } else {
1566 pLayout = NULL;
1567 }
1568 }
1569
vn_sizeof_vkBindImageMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1570 static inline size_t vn_sizeof_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1571 {
1572 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1573 const VkFlags cmd_flags = 0;
1574 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1575
1576 cmd_size += vn_sizeof_VkDevice(&device);
1577 cmd_size += vn_sizeof_uint32_t(&bindInfoCount);
1578 if (pBindInfos) {
1579 cmd_size += vn_sizeof_array_size(bindInfoCount);
1580 for (uint32_t i = 0; i < bindInfoCount; i++)
1581 cmd_size += vn_sizeof_VkBindImageMemoryInfo(&pBindInfos[i]);
1582 } else {
1583 cmd_size += vn_sizeof_array_size(0);
1584 }
1585
1586 return cmd_size;
1587 }
1588
vn_encode_vkBindImageMemory2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1589 static inline void vn_encode_vkBindImageMemory2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1590 {
1591 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1592
1593 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1594 vn_encode_VkFlags(enc, &cmd_flags);
1595
1596 vn_encode_VkDevice(enc, &device);
1597 vn_encode_uint32_t(enc, &bindInfoCount);
1598 if (pBindInfos) {
1599 vn_encode_array_size(enc, bindInfoCount);
1600 for (uint32_t i = 0; i < bindInfoCount; i++)
1601 vn_encode_VkBindImageMemoryInfo(enc, &pBindInfos[i]);
1602 } else {
1603 vn_encode_array_size(enc, 0);
1604 }
1605 }
1606
vn_sizeof_vkBindImageMemory2_reply(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1607 static inline size_t vn_sizeof_vkBindImageMemory2_reply(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1608 {
1609 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkBindImageMemory2_EXT;
1610 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1611
1612 VkResult ret;
1613 cmd_size += vn_sizeof_VkResult(&ret);
1614 /* skip device */
1615 /* skip bindInfoCount */
1616 /* skip pBindInfos */
1617
1618 return cmd_size;
1619 }
1620
vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)1621 static inline VkResult vn_decode_vkBindImageMemory2_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1622 {
1623 VkCommandTypeEXT command_type;
1624 vn_decode_VkCommandTypeEXT(dec, &command_type);
1625 assert(command_type == VK_COMMAND_TYPE_vkBindImageMemory2_EXT);
1626
1627 VkResult ret;
1628 vn_decode_VkResult(dec, &ret);
1629 /* skip device */
1630 /* skip bindInfoCount */
1631 /* skip pBindInfos */
1632
1633 return ret;
1634 }
1635
vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1636 static inline size_t vn_sizeof_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1637 {
1638 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1639 const VkFlags cmd_flags = 0;
1640 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1641
1642 cmd_size += vn_sizeof_VkDevice(&device);
1643 cmd_size += vn_sizeof_simple_pointer(pInfo);
1644 if (pInfo)
1645 cmd_size += vn_sizeof_VkImageMemoryRequirementsInfo2(pInfo);
1646 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1647 if (pMemoryRequirements)
1648 cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
1649
1650 return cmd_size;
1651 }
1652
vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1653 static inline void vn_encode_vkGetImageMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1654 {
1655 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1656
1657 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1658 vn_encode_VkFlags(enc, &cmd_flags);
1659
1660 vn_encode_VkDevice(enc, &device);
1661 if (vn_encode_simple_pointer(enc, pInfo))
1662 vn_encode_VkImageMemoryRequirementsInfo2(enc, pInfo);
1663 if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1664 vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
1665 }
1666
vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1667 static inline size_t vn_sizeof_vkGetImageMemoryRequirements2_reply(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1668 {
1669 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT;
1670 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1671
1672 /* skip device */
1673 /* skip pInfo */
1674 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1675 if (pMemoryRequirements)
1676 cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
1677
1678 return cmd_size;
1679 }
1680
vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1681 static inline void vn_decode_vkGetImageMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1682 {
1683 VkCommandTypeEXT command_type;
1684 vn_decode_VkCommandTypeEXT(dec, &command_type);
1685 assert(command_type == VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT);
1686
1687 /* skip device */
1688 /* skip pInfo */
1689 if (vn_decode_simple_pointer(dec)) {
1690 vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
1691 } else {
1692 pMemoryRequirements = NULL;
1693 }
1694 }
1695
vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1696 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1697 {
1698 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1699 const VkFlags cmd_flags = 0;
1700 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1701
1702 cmd_size += vn_sizeof_VkDevice(&device);
1703 cmd_size += vn_sizeof_simple_pointer(pInfo);
1704 if (pInfo)
1705 cmd_size += vn_sizeof_VkImageSparseMemoryRequirementsInfo2(pInfo);
1706 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1707 if (pSparseMemoryRequirementCount)
1708 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1709 if (pSparseMemoryRequirements) {
1710 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1711 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1712 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
1713 } else {
1714 cmd_size += vn_sizeof_array_size(0);
1715 }
1716
1717 return cmd_size;
1718 }
1719
vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1720 static inline void vn_encode_vkGetImageSparseMemoryRequirements2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1721 {
1722 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1723
1724 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1725 vn_encode_VkFlags(enc, &cmd_flags);
1726
1727 vn_encode_VkDevice(enc, &device);
1728 if (vn_encode_simple_pointer(enc, pInfo))
1729 vn_encode_VkImageSparseMemoryRequirementsInfo2(enc, pInfo);
1730 if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1731 vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1732 if (pSparseMemoryRequirements) {
1733 vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1734 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1735 vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
1736 } else {
1737 vn_encode_array_size(enc, 0);
1738 }
1739 }
1740
vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1741 static inline size_t vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1742 {
1743 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT;
1744 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1745
1746 /* skip device */
1747 /* skip pInfo */
1748 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1749 if (pSparseMemoryRequirementCount)
1750 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1751 if (pSparseMemoryRequirements) {
1752 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1753 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1754 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
1755 } else {
1756 cmd_size += vn_sizeof_array_size(0);
1757 }
1758
1759 return cmd_size;
1760 }
1761
vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1762 static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1763 {
1764 VkCommandTypeEXT command_type;
1765 vn_decode_VkCommandTypeEXT(dec, &command_type);
1766 assert(command_type == VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT);
1767
1768 /* skip device */
1769 /* skip pInfo */
1770 if (vn_decode_simple_pointer(dec)) {
1771 vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1772 } else {
1773 pSparseMemoryRequirementCount = NULL;
1774 }
1775 if (vn_peek_array_size(dec)) {
1776 const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1777 for (uint32_t i = 0; i < iter_count; i++)
1778 vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
1779 } else {
1780 vn_decode_array_size_unchecked(dec);
1781 pSparseMemoryRequirements = NULL;
1782 }
1783 }
1784
vn_sizeof_vkGetDeviceImageMemoryRequirements(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1785 static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1786 {
1787 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
1788 const VkFlags cmd_flags = 0;
1789 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1790
1791 cmd_size += vn_sizeof_VkDevice(&device);
1792 cmd_size += vn_sizeof_simple_pointer(pInfo);
1793 if (pInfo)
1794 cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
1795 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1796 if (pMemoryRequirements)
1797 cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
1798
1799 return cmd_size;
1800 }
1801
vn_encode_vkGetDeviceImageMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1802 static inline void vn_encode_vkGetDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1803 {
1804 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
1805
1806 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1807 vn_encode_VkFlags(enc, &cmd_flags);
1808
1809 vn_encode_VkDevice(enc, &device);
1810 if (vn_encode_simple_pointer(enc, pInfo))
1811 vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
1812 if (vn_encode_simple_pointer(enc, pMemoryRequirements))
1813 vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
1814 }
1815
vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1816 static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1817 {
1818 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
1819 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1820
1821 /* skip device */
1822 /* skip pInfo */
1823 cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
1824 if (pMemoryRequirements)
1825 cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
1826
1827 return cmd_size;
1828 }
1829
vn_decode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)1830 static inline void vn_decode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1831 {
1832 VkCommandTypeEXT command_type;
1833 vn_decode_VkCommandTypeEXT(dec, &command_type);
1834 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT);
1835
1836 /* skip device */
1837 /* skip pInfo */
1838 if (vn_decode_simple_pointer(dec)) {
1839 vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
1840 } else {
1841 pMemoryRequirements = NULL;
1842 }
1843 }
1844
vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1845 static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1846 {
1847 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
1848 const VkFlags cmd_flags = 0;
1849 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1850
1851 cmd_size += vn_sizeof_VkDevice(&device);
1852 cmd_size += vn_sizeof_simple_pointer(pInfo);
1853 if (pInfo)
1854 cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
1855 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1856 if (pSparseMemoryRequirementCount)
1857 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1858 if (pSparseMemoryRequirements) {
1859 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1860 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1861 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
1862 } else {
1863 cmd_size += vn_sizeof_array_size(0);
1864 }
1865
1866 return cmd_size;
1867 }
1868
vn_encode_vkGetDeviceImageSparseMemoryRequirements(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1869 static inline void vn_encode_vkGetDeviceImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1870 {
1871 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
1872
1873 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1874 vn_encode_VkFlags(enc, &cmd_flags);
1875
1876 vn_encode_VkDevice(enc, &device);
1877 if (vn_encode_simple_pointer(enc, pInfo))
1878 vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
1879 if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
1880 vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
1881 if (pSparseMemoryRequirements) {
1882 vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1883 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1884 vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
1885 } else {
1886 vn_encode_array_size(enc, 0);
1887 }
1888 }
1889
vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1890 static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1891 {
1892 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
1893 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1894
1895 /* skip device */
1896 /* skip pInfo */
1897 cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
1898 if (pSparseMemoryRequirementCount)
1899 cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
1900 if (pSparseMemoryRequirements) {
1901 cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1902 for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
1903 cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
1904 } else {
1905 cmd_size += vn_sizeof_array_size(0);
1906 }
1907
1908 return cmd_size;
1909 }
1910
vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)1911 static inline void vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1912 {
1913 VkCommandTypeEXT command_type;
1914 vn_decode_VkCommandTypeEXT(dec, &command_type);
1915 assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT);
1916
1917 /* skip device */
1918 /* skip pInfo */
1919 if (vn_decode_simple_pointer(dec)) {
1920 vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
1921 } else {
1922 pSparseMemoryRequirementCount = NULL;
1923 }
1924 if (vn_peek_array_size(dec)) {
1925 const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
1926 for (uint32_t i = 0; i < iter_count; i++)
1927 vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
1928 } else {
1929 vn_decode_array_size_unchecked(dec);
1930 pSparseMemoryRequirements = NULL;
1931 }
1932 }
1933
vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)1934 static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1935 {
1936 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
1937 const VkFlags cmd_flags = 0;
1938 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
1939
1940 cmd_size += vn_sizeof_VkDevice(&device);
1941 cmd_size += vn_sizeof_VkImage(&image);
1942 cmd_size += vn_sizeof_simple_pointer(pProperties);
1943 if (pProperties)
1944 cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT_partial(pProperties);
1945
1946 return cmd_size;
1947 }
1948
vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)1949 static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1950 {
1951 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
1952
1953 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
1954 vn_encode_VkFlags(enc, &cmd_flags);
1955
1956 vn_encode_VkDevice(enc, &device);
1957 vn_encode_VkImage(enc, &image);
1958 if (vn_encode_simple_pointer(enc, pProperties))
1959 vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(enc, pProperties);
1960 }
1961
vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)1962 static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1963 {
1964 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
1965 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
1966
1967 VkResult ret;
1968 cmd_size += vn_sizeof_VkResult(&ret);
1969 /* skip device */
1970 /* skip image */
1971 cmd_size += vn_sizeof_simple_pointer(pProperties);
1972 if (pProperties)
1973 cmd_size += vn_sizeof_VkImageDrmFormatModifierPropertiesEXT(pProperties);
1974
1975 return cmd_size;
1976 }
1977
vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder * dec,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)1978 static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
1979 {
1980 VkCommandTypeEXT command_type;
1981 vn_decode_VkCommandTypeEXT(dec, &command_type);
1982 assert(command_type == VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT);
1983
1984 VkResult ret;
1985 vn_decode_VkResult(dec, &ret);
1986 /* skip device */
1987 /* skip image */
1988 if (vn_decode_simple_pointer(dec)) {
1989 vn_decode_VkImageDrmFormatModifierPropertiesEXT(dec, pProperties);
1990 } else {
1991 pProperties = NULL;
1992 }
1993
1994 return ret;
1995 }
1996
vn_submit_vkGetImageMemoryRequirements(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements,struct vn_instance_submit_command * submit)1997 static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_instance_submit_command *submit)
1998 {
1999 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2000 void *cmd_data = local_cmd_data;
2001 size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
2002 if (cmd_size > sizeof(local_cmd_data)) {
2003 cmd_data = malloc(cmd_size);
2004 if (!cmd_data)
2005 cmd_size = 0;
2006 }
2007 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0;
2008
2009 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2010 if (cmd_size) {
2011 vn_encode_vkGetImageMemoryRequirements(enc, cmd_flags, device, image, pMemoryRequirements);
2012 vn_instance_submit_command(vn_instance, submit);
2013 if (cmd_data != local_cmd_data)
2014 free(cmd_data);
2015 }
2016 }
2017
vn_submit_vkBindImageMemory(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset,struct vn_instance_submit_command * submit)2018 static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
2019 {
2020 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2021 void *cmd_data = local_cmd_data;
2022 size_t cmd_size = vn_sizeof_vkBindImageMemory(device, image, memory, memoryOffset);
2023 if (cmd_size > sizeof(local_cmd_data)) {
2024 cmd_data = malloc(cmd_size);
2025 if (!cmd_data)
2026 cmd_size = 0;
2027 }
2028 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0;
2029
2030 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2031 if (cmd_size) {
2032 vn_encode_vkBindImageMemory(enc, cmd_flags, device, image, memory, memoryOffset);
2033 vn_instance_submit_command(vn_instance, submit);
2034 if (cmd_data != local_cmd_data)
2035 free(cmd_data);
2036 }
2037 }
2038
vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements,struct vn_instance_submit_command * submit)2039 static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
2040 {
2041 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2042 void *cmd_data = local_cmd_data;
2043 size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2044 if (cmd_size > sizeof(local_cmd_data)) {
2045 cmd_data = malloc(cmd_size);
2046 if (!cmd_data)
2047 cmd_size = 0;
2048 }
2049 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2050
2051 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2052 if (cmd_size) {
2053 vn_encode_vkGetImageSparseMemoryRequirements(enc, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2054 vn_instance_submit_command(vn_instance, submit);
2055 if (cmd_data != local_cmd_data)
2056 free(cmd_data);
2057 }
2058 }
2059
vn_submit_vkCreateImage(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage,struct vn_instance_submit_command * submit)2060 static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_instance_submit_command *submit)
2061 {
2062 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2063 void *cmd_data = local_cmd_data;
2064 size_t cmd_size = vn_sizeof_vkCreateImage(device, pCreateInfo, pAllocator, pImage);
2065 if (cmd_size > sizeof(local_cmd_data)) {
2066 cmd_data = malloc(cmd_size);
2067 if (!cmd_data)
2068 cmd_size = 0;
2069 }
2070 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0;
2071
2072 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2073 if (cmd_size) {
2074 vn_encode_vkCreateImage(enc, cmd_flags, device, pCreateInfo, pAllocator, pImage);
2075 vn_instance_submit_command(vn_instance, submit);
2076 if (cmd_data != local_cmd_data)
2077 free(cmd_data);
2078 }
2079 }
2080
vn_submit_vkDestroyImage(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator,struct vn_instance_submit_command * submit)2081 static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
2082 {
2083 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2084 void *cmd_data = local_cmd_data;
2085 size_t cmd_size = vn_sizeof_vkDestroyImage(device, image, pAllocator);
2086 if (cmd_size > sizeof(local_cmd_data)) {
2087 cmd_data = malloc(cmd_size);
2088 if (!cmd_data)
2089 cmd_size = 0;
2090 }
2091 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0;
2092
2093 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2094 if (cmd_size) {
2095 vn_encode_vkDestroyImage(enc, cmd_flags, device, image, pAllocator);
2096 vn_instance_submit_command(vn_instance, submit);
2097 if (cmd_data != local_cmd_data)
2098 free(cmd_data);
2099 }
2100 }
2101
vn_submit_vkGetImageSubresourceLayout(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout,struct vn_instance_submit_command * submit)2102 static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_instance_submit_command *submit)
2103 {
2104 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2105 void *cmd_data = local_cmd_data;
2106 size_t cmd_size = vn_sizeof_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
2107 if (cmd_size > sizeof(local_cmd_data)) {
2108 cmd_data = malloc(cmd_size);
2109 if (!cmd_data)
2110 cmd_size = 0;
2111 }
2112 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0;
2113
2114 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2115 if (cmd_size) {
2116 vn_encode_vkGetImageSubresourceLayout(enc, cmd_flags, device, image, pSubresource, pLayout);
2117 vn_instance_submit_command(vn_instance, submit);
2118 if (cmd_data != local_cmd_data)
2119 free(cmd_data);
2120 }
2121 }
2122
vn_submit_vkBindImageMemory2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos,struct vn_instance_submit_command * submit)2123 static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
2124 {
2125 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2126 void *cmd_data = local_cmd_data;
2127 size_t cmd_size = vn_sizeof_vkBindImageMemory2(device, bindInfoCount, pBindInfos);
2128 if (cmd_size > sizeof(local_cmd_data)) {
2129 cmd_data = malloc(cmd_size);
2130 if (!cmd_data)
2131 cmd_size = 0;
2132 }
2133 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
2134
2135 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2136 if (cmd_size) {
2137 vn_encode_vkBindImageMemory2(enc, cmd_flags, device, bindInfoCount, pBindInfos);
2138 vn_instance_submit_command(vn_instance, submit);
2139 if (cmd_data != local_cmd_data)
2140 free(cmd_data);
2141 }
2142 }
2143
vn_submit_vkGetImageMemoryRequirements2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements,struct vn_instance_submit_command * submit)2144 static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
2145 {
2146 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2147 void *cmd_data = local_cmd_data;
2148 size_t cmd_size = vn_sizeof_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
2149 if (cmd_size > sizeof(local_cmd_data)) {
2150 cmd_data = malloc(cmd_size);
2151 if (!cmd_data)
2152 cmd_size = 0;
2153 }
2154 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
2155
2156 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2157 if (cmd_size) {
2158 vn_encode_vkGetImageMemoryRequirements2(enc, cmd_flags, device, pInfo, pMemoryRequirements);
2159 vn_instance_submit_command(vn_instance, submit);
2160 if (cmd_data != local_cmd_data)
2161 free(cmd_data);
2162 }
2163 }
2164
vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements,struct vn_instance_submit_command * submit)2165 static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
2166 {
2167 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2168 void *cmd_data = local_cmd_data;
2169 size_t cmd_size = vn_sizeof_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2170 if (cmd_size > sizeof(local_cmd_data)) {
2171 cmd_data = malloc(cmd_size);
2172 if (!cmd_data)
2173 cmd_size = 0;
2174 }
2175 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2176
2177 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2178 if (cmd_size) {
2179 vn_encode_vkGetImageSparseMemoryRequirements2(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2180 vn_instance_submit_command(vn_instance, submit);
2181 if (cmd_data != local_cmd_data)
2182 free(cmd_data);
2183 }
2184 }
2185
vn_submit_vkGetDeviceImageMemoryRequirements(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements,struct vn_instance_submit_command * submit)2186 static inline void vn_submit_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
2187 {
2188 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2189 void *cmd_data = local_cmd_data;
2190 size_t cmd_size = vn_sizeof_vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
2191 if (cmd_size > sizeof(local_cmd_data)) {
2192 cmd_data = malloc(cmd_size);
2193 if (!cmd_data)
2194 cmd_size = 0;
2195 }
2196 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(device, pInfo, pMemoryRequirements) : 0;
2197
2198 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2199 if (cmd_size) {
2200 vn_encode_vkGetDeviceImageMemoryRequirements(enc, cmd_flags, device, pInfo, pMemoryRequirements);
2201 vn_instance_submit_command(vn_instance, submit);
2202 if (cmd_data != local_cmd_data)
2203 free(cmd_data);
2204 }
2205 }
2206
vn_submit_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements,struct vn_instance_submit_command * submit)2207 static inline void vn_submit_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
2208 {
2209 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2210 void *cmd_data = local_cmd_data;
2211 size_t cmd_size = vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2212 if (cmd_size > sizeof(local_cmd_data)) {
2213 cmd_data = malloc(cmd_size);
2214 if (!cmd_data)
2215 cmd_size = 0;
2216 }
2217 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
2218
2219 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2220 if (cmd_size) {
2221 vn_encode_vkGetDeviceImageSparseMemoryRequirements(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2222 vn_instance_submit_command(vn_instance, submit);
2223 if (cmd_data != local_cmd_data)
2224 free(cmd_data);
2225 }
2226 }
2227
vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties,struct vn_instance_submit_command * submit)2228 static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit)
2229 {
2230 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2231 void *cmd_data = local_cmd_data;
2232 size_t cmd_size = vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
2233 if (cmd_size > sizeof(local_cmd_data)) {
2234 cmd_data = malloc(cmd_size);
2235 if (!cmd_data)
2236 cmd_size = 0;
2237 }
2238 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0;
2239
2240 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2241 if (cmd_size) {
2242 vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(enc, cmd_flags, device, image, pProperties);
2243 vn_instance_submit_command(vn_instance, submit);
2244 if (cmd_data != local_cmd_data)
2245 free(cmd_data);
2246 }
2247 }
2248
vn_call_vkGetImageMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)2249 static inline void vn_call_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
2250 {
2251 VN_TRACE_FUNC();
2252
2253 struct vn_instance_submit_command submit;
2254 vn_submit_vkGetImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit);
2255 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2256 if (dec) {
2257 vn_decode_vkGetImageMemoryRequirements_reply(dec, device, image, pMemoryRequirements);
2258 vn_instance_free_command_reply(vn_instance, &submit);
2259 }
2260 }
2261
vn_async_vkGetImageMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)2262 static inline void vn_async_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
2263 {
2264 struct vn_instance_submit_command submit;
2265 vn_submit_vkGetImageMemoryRequirements(vn_instance, 0, device, image, pMemoryRequirements, &submit);
2266 }
2267
vn_call_vkBindImageMemory(struct vn_instance * vn_instance,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)2268 static inline VkResult vn_call_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
2269 {
2270 VN_TRACE_FUNC();
2271
2272 struct vn_instance_submit_command submit;
2273 vn_submit_vkBindImageMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit);
2274 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2275 if (dec) {
2276 const VkResult ret = vn_decode_vkBindImageMemory_reply(dec, device, image, memory, memoryOffset);
2277 vn_instance_free_command_reply(vn_instance, &submit);
2278 return ret;
2279 } else {
2280 return VK_ERROR_OUT_OF_HOST_MEMORY;
2281 }
2282 }
2283
vn_async_vkBindImageMemory(struct vn_instance * vn_instance,VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)2284 static inline void vn_async_vkBindImageMemory(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
2285 {
2286 struct vn_instance_submit_command submit;
2287 vn_submit_vkBindImageMemory(vn_instance, 0, device, image, memory, memoryOffset, &submit);
2288 }
2289
vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)2290 static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
2291 {
2292 VN_TRACE_FUNC();
2293
2294 struct vn_instance_submit_command submit;
2295 vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2296 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2297 if (dec) {
2298 vn_decode_vkGetImageSparseMemoryRequirements_reply(dec, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2299 vn_instance_free_command_reply(vn_instance, &submit);
2300 }
2301 }
2302
vn_async_vkGetImageSparseMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)2303 static inline void vn_async_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
2304 {
2305 struct vn_instance_submit_command submit;
2306 vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, 0, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2307 }
2308
vn_call_vkCreateImage(struct vn_instance * vn_instance,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)2309 static inline VkResult vn_call_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
2310 {
2311 VN_TRACE_FUNC();
2312
2313 struct vn_instance_submit_command submit;
2314 vn_submit_vkCreateImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit);
2315 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2316 if (dec) {
2317 const VkResult ret = vn_decode_vkCreateImage_reply(dec, device, pCreateInfo, pAllocator, pImage);
2318 vn_instance_free_command_reply(vn_instance, &submit);
2319 return ret;
2320 } else {
2321 return VK_ERROR_OUT_OF_HOST_MEMORY;
2322 }
2323 }
2324
vn_async_vkCreateImage(struct vn_instance * vn_instance,VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)2325 static inline void vn_async_vkCreateImage(struct vn_instance *vn_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
2326 {
2327 struct vn_instance_submit_command submit;
2328 vn_submit_vkCreateImage(vn_instance, 0, device, pCreateInfo, pAllocator, pImage, &submit);
2329 }
2330
vn_call_vkDestroyImage(struct vn_instance * vn_instance,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)2331 static inline void vn_call_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
2332 {
2333 VN_TRACE_FUNC();
2334
2335 struct vn_instance_submit_command submit;
2336 vn_submit_vkDestroyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit);
2337 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2338 if (dec) {
2339 vn_decode_vkDestroyImage_reply(dec, device, image, pAllocator);
2340 vn_instance_free_command_reply(vn_instance, &submit);
2341 }
2342 }
2343
vn_async_vkDestroyImage(struct vn_instance * vn_instance,VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)2344 static inline void vn_async_vkDestroyImage(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
2345 {
2346 struct vn_instance_submit_command submit;
2347 vn_submit_vkDestroyImage(vn_instance, 0, device, image, pAllocator, &submit);
2348 }
2349
vn_call_vkGetImageSubresourceLayout(struct vn_instance * vn_instance,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)2350 static inline void vn_call_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
2351 {
2352 VN_TRACE_FUNC();
2353
2354 struct vn_instance_submit_command submit;
2355 vn_submit_vkGetImageSubresourceLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
2356 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2357 if (dec) {
2358 vn_decode_vkGetImageSubresourceLayout_reply(dec, device, image, pSubresource, pLayout);
2359 vn_instance_free_command_reply(vn_instance, &submit);
2360 }
2361 }
2362
vn_async_vkGetImageSubresourceLayout(struct vn_instance * vn_instance,VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)2363 static inline void vn_async_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
2364 {
2365 struct vn_instance_submit_command submit;
2366 vn_submit_vkGetImageSubresourceLayout(vn_instance, 0, device, image, pSubresource, pLayout, &submit);
2367 }
2368
vn_call_vkBindImageMemory2(struct vn_instance * vn_instance,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)2369 static inline VkResult vn_call_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
2370 {
2371 VN_TRACE_FUNC();
2372
2373 struct vn_instance_submit_command submit;
2374 vn_submit_vkBindImageMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
2375 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2376 if (dec) {
2377 const VkResult ret = vn_decode_vkBindImageMemory2_reply(dec, device, bindInfoCount, pBindInfos);
2378 vn_instance_free_command_reply(vn_instance, &submit);
2379 return ret;
2380 } else {
2381 return VK_ERROR_OUT_OF_HOST_MEMORY;
2382 }
2383 }
2384
vn_async_vkBindImageMemory2(struct vn_instance * vn_instance,VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos)2385 static inline void vn_async_vkBindImageMemory2(struct vn_instance *vn_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
2386 {
2387 struct vn_instance_submit_command submit;
2388 vn_submit_vkBindImageMemory2(vn_instance, 0, device, bindInfoCount, pBindInfos, &submit);
2389 }
2390
vn_call_vkGetImageMemoryRequirements2(struct vn_instance * vn_instance,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2391 static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2392 {
2393 VN_TRACE_FUNC();
2394
2395 struct vn_instance_submit_command submit;
2396 vn_submit_vkGetImageMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
2397 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2398 if (dec) {
2399 vn_decode_vkGetImageMemoryRequirements2_reply(dec, device, pInfo, pMemoryRequirements);
2400 vn_instance_free_command_reply(vn_instance, &submit);
2401 }
2402 }
2403
vn_async_vkGetImageMemoryRequirements2(struct vn_instance * vn_instance,VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2404 static inline void vn_async_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2405 {
2406 struct vn_instance_submit_command submit;
2407 vn_submit_vkGetImageMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
2408 }
2409
vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instance * vn_instance,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2410 static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2411 {
2412 VN_TRACE_FUNC();
2413
2414 struct vn_instance_submit_command submit;
2415 vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2416 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2417 if (dec) {
2418 vn_decode_vkGetImageSparseMemoryRequirements2_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2419 vn_instance_free_command_reply(vn_instance, &submit);
2420 }
2421 }
2422
vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instance * vn_instance,VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2423 static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2424 {
2425 struct vn_instance_submit_command submit;
2426 vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2427 }
2428
vn_call_vkGetDeviceImageMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2429 static inline void vn_call_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2430 {
2431 VN_TRACE_FUNC();
2432
2433 struct vn_instance_submit_command submit;
2434 vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
2435 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2436 if (dec) {
2437 vn_decode_vkGetDeviceImageMemoryRequirements_reply(dec, device, pInfo, pMemoryRequirements);
2438 vn_instance_free_command_reply(vn_instance, &submit);
2439 }
2440 }
2441
vn_async_vkGetDeviceImageMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements)2442 static inline void vn_async_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2443 {
2444 struct vn_instance_submit_command submit;
2445 vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
2446 }
2447
vn_call_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2448 static inline void vn_call_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2449 {
2450 VN_TRACE_FUNC();
2451
2452 struct vn_instance_submit_command submit;
2453 vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2454 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2455 if (dec) {
2456 vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2457 vn_instance_free_command_reply(vn_instance, &submit);
2458 }
2459 }
2460
vn_async_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance * vn_instance,VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements)2461 static inline void vn_async_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
2462 {
2463 struct vn_instance_submit_command submit;
2464 vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
2465 }
2466
vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance * vn_instance,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2467 static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2468 {
2469 VN_TRACE_FUNC();
2470
2471 struct vn_instance_submit_command submit;
2472 vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit);
2473 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2474 if (dec) {
2475 const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(dec, device, image, pProperties);
2476 vn_instance_free_command_reply(vn_instance, &submit);
2477 return ret;
2478 } else {
2479 return VK_ERROR_OUT_OF_HOST_MEMORY;
2480 }
2481 }
2482
vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance * vn_instance,VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties)2483 static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2484 {
2485 struct vn_instance_submit_command submit;
2486 vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, 0, device, image, pProperties, &submit);
2487 }
2488
2489 #endif /* VN_PROTOCOL_DRIVER_IMAGE_H */
2490