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