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_STRUCTS_H
9 #define VN_PROTOCOL_DRIVER_STRUCTS_H
10
11 #include "vn_protocol_driver_handles.h"
12
13 /*
14 * These structs/unions/commands are not included
15 *
16 * VkAllocationCallbacks
17 */
18
19 /* struct VkExtent3D */
20
21 static inline size_t
vn_sizeof_VkExtent3D(const VkExtent3D * val)22 vn_sizeof_VkExtent3D(const VkExtent3D *val)
23 {
24 size_t size = 0;
25 size += vn_sizeof_uint32_t(&val->width);
26 size += vn_sizeof_uint32_t(&val->height);
27 size += vn_sizeof_uint32_t(&val->depth);
28 return size;
29 }
30
31 static inline void
vn_encode_VkExtent3D(struct vn_cs_encoder * enc,const VkExtent3D * val)32 vn_encode_VkExtent3D(struct vn_cs_encoder *enc, const VkExtent3D *val)
33 {
34 vn_encode_uint32_t(enc, &val->width);
35 vn_encode_uint32_t(enc, &val->height);
36 vn_encode_uint32_t(enc, &val->depth);
37 }
38
39 static inline void
vn_decode_VkExtent3D(struct vn_cs_decoder * dec,VkExtent3D * val)40 vn_decode_VkExtent3D(struct vn_cs_decoder *dec, VkExtent3D *val)
41 {
42 vn_decode_uint32_t(dec, &val->width);
43 vn_decode_uint32_t(dec, &val->height);
44 vn_decode_uint32_t(dec, &val->depth);
45 }
46
47 static inline size_t
vn_sizeof_VkExtent3D_partial(const VkExtent3D * val)48 vn_sizeof_VkExtent3D_partial(const VkExtent3D *val)
49 {
50 size_t size = 0;
51 /* skip val->width */
52 /* skip val->height */
53 /* skip val->depth */
54 return size;
55 }
56
57 static inline void
vn_encode_VkExtent3D_partial(struct vn_cs_encoder * enc,const VkExtent3D * val)58 vn_encode_VkExtent3D_partial(struct vn_cs_encoder *enc, const VkExtent3D *val)
59 {
60 /* skip val->width */
61 /* skip val->height */
62 /* skip val->depth */
63 }
64
65 /* struct VkLayerProperties */
66
67 static inline size_t
vn_sizeof_VkLayerProperties(const VkLayerProperties * val)68 vn_sizeof_VkLayerProperties(const VkLayerProperties *val)
69 {
70 size_t size = 0;
71 size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
72 size += vn_sizeof_char_array(val->layerName, VK_MAX_EXTENSION_NAME_SIZE);
73 size += vn_sizeof_uint32_t(&val->specVersion);
74 size += vn_sizeof_uint32_t(&val->implementationVersion);
75 size += vn_sizeof_array_size(VK_MAX_DESCRIPTION_SIZE);
76 size += vn_sizeof_char_array(val->description, VK_MAX_DESCRIPTION_SIZE);
77 return size;
78 }
79
80 static inline void
vn_decode_VkLayerProperties(struct vn_cs_decoder * dec,VkLayerProperties * val)81 vn_decode_VkLayerProperties(struct vn_cs_decoder *dec, VkLayerProperties *val)
82 {
83 {
84 const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
85 vn_decode_char_array(dec, val->layerName, array_size);
86 }
87 vn_decode_uint32_t(dec, &val->specVersion);
88 vn_decode_uint32_t(dec, &val->implementationVersion);
89 {
90 const size_t array_size = vn_decode_array_size(dec, VK_MAX_DESCRIPTION_SIZE);
91 vn_decode_char_array(dec, val->description, array_size);
92 }
93 }
94
95 static inline size_t
vn_sizeof_VkLayerProperties_partial(const VkLayerProperties * val)96 vn_sizeof_VkLayerProperties_partial(const VkLayerProperties *val)
97 {
98 size_t size = 0;
99 /* skip val->layerName */
100 /* skip val->specVersion */
101 /* skip val->implementationVersion */
102 /* skip val->description */
103 return size;
104 }
105
106 static inline void
vn_encode_VkLayerProperties_partial(struct vn_cs_encoder * enc,const VkLayerProperties * val)107 vn_encode_VkLayerProperties_partial(struct vn_cs_encoder *enc, const VkLayerProperties *val)
108 {
109 /* skip val->layerName */
110 /* skip val->specVersion */
111 /* skip val->implementationVersion */
112 /* skip val->description */
113 }
114
115 /* struct VkExtensionProperties */
116
117 static inline size_t
vn_sizeof_VkExtensionProperties(const VkExtensionProperties * val)118 vn_sizeof_VkExtensionProperties(const VkExtensionProperties *val)
119 {
120 size_t size = 0;
121 size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
122 size += vn_sizeof_char_array(val->extensionName, VK_MAX_EXTENSION_NAME_SIZE);
123 size += vn_sizeof_uint32_t(&val->specVersion);
124 return size;
125 }
126
127 static inline void
vn_encode_VkExtensionProperties(struct vn_cs_encoder * enc,const VkExtensionProperties * val)128 vn_encode_VkExtensionProperties(struct vn_cs_encoder *enc, const VkExtensionProperties *val)
129 {
130 vn_encode_array_size(enc, VK_MAX_EXTENSION_NAME_SIZE);
131 vn_encode_char_array(enc, val->extensionName, VK_MAX_EXTENSION_NAME_SIZE);
132 vn_encode_uint32_t(enc, &val->specVersion);
133 }
134
135 static inline void
vn_decode_VkExtensionProperties(struct vn_cs_decoder * dec,VkExtensionProperties * val)136 vn_decode_VkExtensionProperties(struct vn_cs_decoder *dec, VkExtensionProperties *val)
137 {
138 {
139 const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
140 vn_decode_char_array(dec, val->extensionName, array_size);
141 }
142 vn_decode_uint32_t(dec, &val->specVersion);
143 }
144
145 static inline size_t
vn_sizeof_VkExtensionProperties_partial(const VkExtensionProperties * val)146 vn_sizeof_VkExtensionProperties_partial(const VkExtensionProperties *val)
147 {
148 size_t size = 0;
149 /* skip val->extensionName */
150 /* skip val->specVersion */
151 return size;
152 }
153
154 static inline void
vn_encode_VkExtensionProperties_partial(struct vn_cs_encoder * enc,const VkExtensionProperties * val)155 vn_encode_VkExtensionProperties_partial(struct vn_cs_encoder *enc, const VkExtensionProperties *val)
156 {
157 /* skip val->extensionName */
158 /* skip val->specVersion */
159 }
160
161 /* struct VkMemoryRequirements */
162
163 static inline size_t
vn_sizeof_VkMemoryRequirements(const VkMemoryRequirements * val)164 vn_sizeof_VkMemoryRequirements(const VkMemoryRequirements *val)
165 {
166 size_t size = 0;
167 size += vn_sizeof_VkDeviceSize(&val->size);
168 size += vn_sizeof_VkDeviceSize(&val->alignment);
169 size += vn_sizeof_uint32_t(&val->memoryTypeBits);
170 return size;
171 }
172
173 static inline void
vn_decode_VkMemoryRequirements(struct vn_cs_decoder * dec,VkMemoryRequirements * val)174 vn_decode_VkMemoryRequirements(struct vn_cs_decoder *dec, VkMemoryRequirements *val)
175 {
176 vn_decode_VkDeviceSize(dec, &val->size);
177 vn_decode_VkDeviceSize(dec, &val->alignment);
178 vn_decode_uint32_t(dec, &val->memoryTypeBits);
179 }
180
181 static inline size_t
vn_sizeof_VkMemoryRequirements_partial(const VkMemoryRequirements * val)182 vn_sizeof_VkMemoryRequirements_partial(const VkMemoryRequirements *val)
183 {
184 size_t size = 0;
185 /* skip val->size */
186 /* skip val->alignment */
187 /* skip val->memoryTypeBits */
188 return size;
189 }
190
191 static inline void
vn_encode_VkMemoryRequirements_partial(struct vn_cs_encoder * enc,const VkMemoryRequirements * val)192 vn_encode_VkMemoryRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements *val)
193 {
194 /* skip val->size */
195 /* skip val->alignment */
196 /* skip val->memoryTypeBits */
197 }
198
199 /* struct VkSparseImageFormatProperties */
200
201 static inline size_t
vn_sizeof_VkSparseImageFormatProperties(const VkSparseImageFormatProperties * val)202 vn_sizeof_VkSparseImageFormatProperties(const VkSparseImageFormatProperties *val)
203 {
204 size_t size = 0;
205 size += vn_sizeof_VkFlags(&val->aspectMask);
206 size += vn_sizeof_VkExtent3D(&val->imageGranularity);
207 size += vn_sizeof_VkFlags(&val->flags);
208 return size;
209 }
210
211 static inline void
vn_decode_VkSparseImageFormatProperties(struct vn_cs_decoder * dec,VkSparseImageFormatProperties * val)212 vn_decode_VkSparseImageFormatProperties(struct vn_cs_decoder *dec, VkSparseImageFormatProperties *val)
213 {
214 vn_decode_VkFlags(dec, &val->aspectMask);
215 vn_decode_VkExtent3D(dec, &val->imageGranularity);
216 vn_decode_VkFlags(dec, &val->flags);
217 }
218
219 static inline size_t
vn_sizeof_VkSparseImageFormatProperties_partial(const VkSparseImageFormatProperties * val)220 vn_sizeof_VkSparseImageFormatProperties_partial(const VkSparseImageFormatProperties *val)
221 {
222 size_t size = 0;
223 /* skip val->aspectMask */
224 size += vn_sizeof_VkExtent3D_partial(&val->imageGranularity);
225 /* skip val->flags */
226 return size;
227 }
228
229 static inline void
vn_encode_VkSparseImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties * val)230 vn_encode_VkSparseImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties *val)
231 {
232 /* skip val->aspectMask */
233 vn_encode_VkExtent3D_partial(enc, &val->imageGranularity);
234 /* skip val->flags */
235 }
236
237 /* struct VkImageSubresource */
238
239 static inline size_t
vn_sizeof_VkImageSubresource(const VkImageSubresource * val)240 vn_sizeof_VkImageSubresource(const VkImageSubresource *val)
241 {
242 size_t size = 0;
243 size += vn_sizeof_VkFlags(&val->aspectMask);
244 size += vn_sizeof_uint32_t(&val->mipLevel);
245 size += vn_sizeof_uint32_t(&val->arrayLayer);
246 return size;
247 }
248
249 static inline void
vn_encode_VkImageSubresource(struct vn_cs_encoder * enc,const VkImageSubresource * val)250 vn_encode_VkImageSubresource(struct vn_cs_encoder *enc, const VkImageSubresource *val)
251 {
252 vn_encode_VkFlags(enc, &val->aspectMask);
253 vn_encode_uint32_t(enc, &val->mipLevel);
254 vn_encode_uint32_t(enc, &val->arrayLayer);
255 }
256
257 /* struct VkOffset3D */
258
259 static inline size_t
vn_sizeof_VkOffset3D(const VkOffset3D * val)260 vn_sizeof_VkOffset3D(const VkOffset3D *val)
261 {
262 size_t size = 0;
263 size += vn_sizeof_int32_t(&val->x);
264 size += vn_sizeof_int32_t(&val->y);
265 size += vn_sizeof_int32_t(&val->z);
266 return size;
267 }
268
269 static inline void
vn_encode_VkOffset3D(struct vn_cs_encoder * enc,const VkOffset3D * val)270 vn_encode_VkOffset3D(struct vn_cs_encoder *enc, const VkOffset3D *val)
271 {
272 vn_encode_int32_t(enc, &val->x);
273 vn_encode_int32_t(enc, &val->y);
274 vn_encode_int32_t(enc, &val->z);
275 }
276
277 /* struct VkSemaphoreTypeCreateInfo chain */
278
279 static inline size_t
vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(const void * val)280 vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(const void *val)
281 {
282 /* no known/supported struct */
283 return vn_sizeof_simple_pointer(NULL);
284 }
285
286 static inline size_t
vn_sizeof_VkSemaphoreTypeCreateInfo_self(const VkSemaphoreTypeCreateInfo * val)287 vn_sizeof_VkSemaphoreTypeCreateInfo_self(const VkSemaphoreTypeCreateInfo *val)
288 {
289 size_t size = 0;
290 /* skip val->{sType,pNext} */
291 size += vn_sizeof_VkSemaphoreType(&val->semaphoreType);
292 size += vn_sizeof_uint64_t(&val->initialValue);
293 return size;
294 }
295
296 static inline size_t
vn_sizeof_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo * val)297 vn_sizeof_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo *val)
298 {
299 size_t size = 0;
300
301 size += vn_sizeof_VkStructureType(&val->sType);
302 size += vn_sizeof_VkSemaphoreTypeCreateInfo_pnext(val->pNext);
303 size += vn_sizeof_VkSemaphoreTypeCreateInfo_self(val);
304
305 return size;
306 }
307
308 static inline void
vn_encode_VkSemaphoreTypeCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)309 vn_encode_VkSemaphoreTypeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
310 {
311 /* no known/supported struct */
312 vn_encode_simple_pointer(enc, NULL);
313 }
314
315 static inline void
vn_encode_VkSemaphoreTypeCreateInfo_self(struct vn_cs_encoder * enc,const VkSemaphoreTypeCreateInfo * val)316 vn_encode_VkSemaphoreTypeCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val)
317 {
318 /* skip val->{sType,pNext} */
319 vn_encode_VkSemaphoreType(enc, &val->semaphoreType);
320 vn_encode_uint64_t(enc, &val->initialValue);
321 }
322
323 static inline void
vn_encode_VkSemaphoreTypeCreateInfo(struct vn_cs_encoder * enc,const VkSemaphoreTypeCreateInfo * val)324 vn_encode_VkSemaphoreTypeCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreTypeCreateInfo *val)
325 {
326 assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
327 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO });
328 vn_encode_VkSemaphoreTypeCreateInfo_pnext(enc, val->pNext);
329 vn_encode_VkSemaphoreTypeCreateInfo_self(enc, val);
330 }
331
332 /* struct VkImageFormatListCreateInfo chain */
333
334 static inline size_t
vn_sizeof_VkImageFormatListCreateInfo_pnext(const void * val)335 vn_sizeof_VkImageFormatListCreateInfo_pnext(const void *val)
336 {
337 /* no known/supported struct */
338 return vn_sizeof_simple_pointer(NULL);
339 }
340
341 static inline size_t
vn_sizeof_VkImageFormatListCreateInfo_self(const VkImageFormatListCreateInfo * val)342 vn_sizeof_VkImageFormatListCreateInfo_self(const VkImageFormatListCreateInfo *val)
343 {
344 size_t size = 0;
345 /* skip val->{sType,pNext} */
346 size += vn_sizeof_uint32_t(&val->viewFormatCount);
347 if (val->pViewFormats) {
348 size += vn_sizeof_array_size(val->viewFormatCount);
349 size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount);
350 } else {
351 size += vn_sizeof_array_size(0);
352 }
353 return size;
354 }
355
356 static inline size_t
vn_sizeof_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo * val)357 vn_sizeof_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo *val)
358 {
359 size_t size = 0;
360
361 size += vn_sizeof_VkStructureType(&val->sType);
362 size += vn_sizeof_VkImageFormatListCreateInfo_pnext(val->pNext);
363 size += vn_sizeof_VkImageFormatListCreateInfo_self(val);
364
365 return size;
366 }
367
368 static inline void
vn_encode_VkImageFormatListCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)369 vn_encode_VkImageFormatListCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
370 {
371 /* no known/supported struct */
372 vn_encode_simple_pointer(enc, NULL);
373 }
374
375 static inline void
vn_encode_VkImageFormatListCreateInfo_self(struct vn_cs_encoder * enc,const VkImageFormatListCreateInfo * val)376 vn_encode_VkImageFormatListCreateInfo_self(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
377 {
378 /* skip val->{sType,pNext} */
379 vn_encode_uint32_t(enc, &val->viewFormatCount);
380 if (val->pViewFormats) {
381 vn_encode_array_size(enc, val->viewFormatCount);
382 vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount);
383 } else {
384 vn_encode_array_size(enc, 0);
385 }
386 }
387
388 static inline void
vn_encode_VkImageFormatListCreateInfo(struct vn_cs_encoder * enc,const VkImageFormatListCreateInfo * val)389 vn_encode_VkImageFormatListCreateInfo(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
390 {
391 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
392 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO });
393 vn_encode_VkImageFormatListCreateInfo_pnext(enc, val->pNext);
394 vn_encode_VkImageFormatListCreateInfo_self(enc, val);
395 }
396
397 /* struct VkImageStencilUsageCreateInfo chain */
398
399 static inline size_t
vn_sizeof_VkImageStencilUsageCreateInfo_pnext(const void * val)400 vn_sizeof_VkImageStencilUsageCreateInfo_pnext(const void *val)
401 {
402 /* no known/supported struct */
403 return vn_sizeof_simple_pointer(NULL);
404 }
405
406 static inline size_t
vn_sizeof_VkImageStencilUsageCreateInfo_self(const VkImageStencilUsageCreateInfo * val)407 vn_sizeof_VkImageStencilUsageCreateInfo_self(const VkImageStencilUsageCreateInfo *val)
408 {
409 size_t size = 0;
410 /* skip val->{sType,pNext} */
411 size += vn_sizeof_VkFlags(&val->stencilUsage);
412 return size;
413 }
414
415 static inline size_t
vn_sizeof_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo * val)416 vn_sizeof_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo *val)
417 {
418 size_t size = 0;
419
420 size += vn_sizeof_VkStructureType(&val->sType);
421 size += vn_sizeof_VkImageStencilUsageCreateInfo_pnext(val->pNext);
422 size += vn_sizeof_VkImageStencilUsageCreateInfo_self(val);
423
424 return size;
425 }
426
427 static inline void
vn_encode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)428 vn_encode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
429 {
430 /* no known/supported struct */
431 vn_encode_simple_pointer(enc, NULL);
432 }
433
434 static inline void
vn_encode_VkImageStencilUsageCreateInfo_self(struct vn_cs_encoder * enc,const VkImageStencilUsageCreateInfo * val)435 vn_encode_VkImageStencilUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
436 {
437 /* skip val->{sType,pNext} */
438 vn_encode_VkFlags(enc, &val->stencilUsage);
439 }
440
441 static inline void
vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder * enc,const VkImageStencilUsageCreateInfo * val)442 vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
443 {
444 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
445 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO });
446 vn_encode_VkImageStencilUsageCreateInfo_pnext(enc, val->pNext);
447 vn_encode_VkImageStencilUsageCreateInfo_self(enc, val);
448 }
449
450 /* struct VkComponentMapping */
451
452 static inline size_t
vn_sizeof_VkComponentMapping(const VkComponentMapping * val)453 vn_sizeof_VkComponentMapping(const VkComponentMapping *val)
454 {
455 size_t size = 0;
456 size += vn_sizeof_VkComponentSwizzle(&val->r);
457 size += vn_sizeof_VkComponentSwizzle(&val->g);
458 size += vn_sizeof_VkComponentSwizzle(&val->b);
459 size += vn_sizeof_VkComponentSwizzle(&val->a);
460 return size;
461 }
462
463 static inline void
vn_encode_VkComponentMapping(struct vn_cs_encoder * enc,const VkComponentMapping * val)464 vn_encode_VkComponentMapping(struct vn_cs_encoder *enc, const VkComponentMapping *val)
465 {
466 vn_encode_VkComponentSwizzle(enc, &val->r);
467 vn_encode_VkComponentSwizzle(enc, &val->g);
468 vn_encode_VkComponentSwizzle(enc, &val->b);
469 vn_encode_VkComponentSwizzle(enc, &val->a);
470 }
471
472 static inline void
vn_decode_VkComponentMapping(struct vn_cs_decoder * dec,VkComponentMapping * val)473 vn_decode_VkComponentMapping(struct vn_cs_decoder *dec, VkComponentMapping *val)
474 {
475 vn_decode_VkComponentSwizzle(dec, &val->r);
476 vn_decode_VkComponentSwizzle(dec, &val->g);
477 vn_decode_VkComponentSwizzle(dec, &val->b);
478 vn_decode_VkComponentSwizzle(dec, &val->a);
479 }
480
481 static inline size_t
vn_sizeof_VkComponentMapping_partial(const VkComponentMapping * val)482 vn_sizeof_VkComponentMapping_partial(const VkComponentMapping *val)
483 {
484 size_t size = 0;
485 /* skip val->r */
486 /* skip val->g */
487 /* skip val->b */
488 /* skip val->a */
489 return size;
490 }
491
492 static inline void
vn_encode_VkComponentMapping_partial(struct vn_cs_encoder * enc,const VkComponentMapping * val)493 vn_encode_VkComponentMapping_partial(struct vn_cs_encoder *enc, const VkComponentMapping *val)
494 {
495 /* skip val->r */
496 /* skip val->g */
497 /* skip val->b */
498 /* skip val->a */
499 }
500
501 /* struct VkImageSubresourceRange */
502
503 static inline size_t
vn_sizeof_VkImageSubresourceRange(const VkImageSubresourceRange * val)504 vn_sizeof_VkImageSubresourceRange(const VkImageSubresourceRange *val)
505 {
506 size_t size = 0;
507 size += vn_sizeof_VkFlags(&val->aspectMask);
508 size += vn_sizeof_uint32_t(&val->baseMipLevel);
509 size += vn_sizeof_uint32_t(&val->levelCount);
510 size += vn_sizeof_uint32_t(&val->baseArrayLayer);
511 size += vn_sizeof_uint32_t(&val->layerCount);
512 return size;
513 }
514
515 static inline void
vn_encode_VkImageSubresourceRange(struct vn_cs_encoder * enc,const VkImageSubresourceRange * val)516 vn_encode_VkImageSubresourceRange(struct vn_cs_encoder *enc, const VkImageSubresourceRange *val)
517 {
518 vn_encode_VkFlags(enc, &val->aspectMask);
519 vn_encode_uint32_t(enc, &val->baseMipLevel);
520 vn_encode_uint32_t(enc, &val->levelCount);
521 vn_encode_uint32_t(enc, &val->baseArrayLayer);
522 vn_encode_uint32_t(enc, &val->layerCount);
523 }
524
525 /* struct VkSamplerYcbcrConversionInfo chain */
526
527 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(const void * val)528 vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(const void *val)
529 {
530 /* no known/supported struct */
531 return vn_sizeof_simple_pointer(NULL);
532 }
533
534 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionInfo_self(const VkSamplerYcbcrConversionInfo * val)535 vn_sizeof_VkSamplerYcbcrConversionInfo_self(const VkSamplerYcbcrConversionInfo *val)
536 {
537 size_t size = 0;
538 /* skip val->{sType,pNext} */
539 size += vn_sizeof_VkSamplerYcbcrConversion(&val->conversion);
540 return size;
541 }
542
543 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo * val)544 vn_sizeof_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo *val)
545 {
546 size_t size = 0;
547
548 size += vn_sizeof_VkStructureType(&val->sType);
549 size += vn_sizeof_VkSamplerYcbcrConversionInfo_pnext(val->pNext);
550 size += vn_sizeof_VkSamplerYcbcrConversionInfo_self(val);
551
552 return size;
553 }
554
555 static inline void
vn_encode_VkSamplerYcbcrConversionInfo_pnext(struct vn_cs_encoder * enc,const void * val)556 vn_encode_VkSamplerYcbcrConversionInfo_pnext(struct vn_cs_encoder *enc, const void *val)
557 {
558 /* no known/supported struct */
559 vn_encode_simple_pointer(enc, NULL);
560 }
561
562 static inline void
vn_encode_VkSamplerYcbcrConversionInfo_self(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionInfo * val)563 vn_encode_VkSamplerYcbcrConversionInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val)
564 {
565 /* skip val->{sType,pNext} */
566 vn_encode_VkSamplerYcbcrConversion(enc, &val->conversion);
567 }
568
569 static inline void
vn_encode_VkSamplerYcbcrConversionInfo(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionInfo * val)570 vn_encode_VkSamplerYcbcrConversionInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionInfo *val)
571 {
572 assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
573 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO });
574 vn_encode_VkSamplerYcbcrConversionInfo_pnext(enc, val->pNext);
575 vn_encode_VkSamplerYcbcrConversionInfo_self(enc, val);
576 }
577
578 /* struct VkShaderModuleCreateInfo chain */
579
580 static inline size_t
vn_sizeof_VkShaderModuleCreateInfo_pnext(const void * val)581 vn_sizeof_VkShaderModuleCreateInfo_pnext(const void *val)
582 {
583 /* no known/supported struct */
584 return vn_sizeof_simple_pointer(NULL);
585 }
586
587 static inline size_t
vn_sizeof_VkShaderModuleCreateInfo_self(const VkShaderModuleCreateInfo * val)588 vn_sizeof_VkShaderModuleCreateInfo_self(const VkShaderModuleCreateInfo *val)
589 {
590 size_t size = 0;
591 /* skip val->{sType,pNext} */
592 size += vn_sizeof_VkFlags(&val->flags);
593 size += vn_sizeof_size_t(&val->codeSize);
594 if (val->pCode) {
595 size += vn_sizeof_array_size(val->codeSize / 4);
596 size += vn_sizeof_uint32_t_array(val->pCode, val->codeSize / 4);
597 } else {
598 size += vn_sizeof_array_size(0);
599 }
600 return size;
601 }
602
603 static inline size_t
vn_sizeof_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo * val)604 vn_sizeof_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo *val)
605 {
606 size_t size = 0;
607
608 size += vn_sizeof_VkStructureType(&val->sType);
609 size += vn_sizeof_VkShaderModuleCreateInfo_pnext(val->pNext);
610 size += vn_sizeof_VkShaderModuleCreateInfo_self(val);
611
612 return size;
613 }
614
615 static inline void
vn_encode_VkShaderModuleCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)616 vn_encode_VkShaderModuleCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
617 {
618 /* no known/supported struct */
619 vn_encode_simple_pointer(enc, NULL);
620 }
621
622 static inline void
vn_encode_VkShaderModuleCreateInfo_self(struct vn_cs_encoder * enc,const VkShaderModuleCreateInfo * val)623 vn_encode_VkShaderModuleCreateInfo_self(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
624 {
625 /* skip val->{sType,pNext} */
626 vn_encode_VkFlags(enc, &val->flags);
627 vn_encode_size_t(enc, &val->codeSize);
628 if (val->pCode) {
629 vn_encode_array_size(enc, val->codeSize / 4);
630 vn_encode_uint32_t_array(enc, val->pCode, val->codeSize / 4);
631 } else {
632 vn_encode_array_size(enc, 0);
633 }
634 }
635
636 static inline void
vn_encode_VkShaderModuleCreateInfo(struct vn_cs_encoder * enc,const VkShaderModuleCreateInfo * val)637 vn_encode_VkShaderModuleCreateInfo(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
638 {
639 assert(val->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
640 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO });
641 vn_encode_VkShaderModuleCreateInfo_pnext(enc, val->pNext);
642 vn_encode_VkShaderModuleCreateInfo_self(enc, val);
643 }
644
645 /* struct VkViewport */
646
647 static inline size_t
vn_sizeof_VkViewport(const VkViewport * val)648 vn_sizeof_VkViewport(const VkViewport *val)
649 {
650 size_t size = 0;
651 size += vn_sizeof_float(&val->x);
652 size += vn_sizeof_float(&val->y);
653 size += vn_sizeof_float(&val->width);
654 size += vn_sizeof_float(&val->height);
655 size += vn_sizeof_float(&val->minDepth);
656 size += vn_sizeof_float(&val->maxDepth);
657 return size;
658 }
659
660 static inline void
vn_encode_VkViewport(struct vn_cs_encoder * enc,const VkViewport * val)661 vn_encode_VkViewport(struct vn_cs_encoder *enc, const VkViewport *val)
662 {
663 vn_encode_float(enc, &val->x);
664 vn_encode_float(enc, &val->y);
665 vn_encode_float(enc, &val->width);
666 vn_encode_float(enc, &val->height);
667 vn_encode_float(enc, &val->minDepth);
668 vn_encode_float(enc, &val->maxDepth);
669 }
670
671 /* struct VkOffset2D */
672
673 static inline size_t
vn_sizeof_VkOffset2D(const VkOffset2D * val)674 vn_sizeof_VkOffset2D(const VkOffset2D *val)
675 {
676 size_t size = 0;
677 size += vn_sizeof_int32_t(&val->x);
678 size += vn_sizeof_int32_t(&val->y);
679 return size;
680 }
681
682 static inline void
vn_encode_VkOffset2D(struct vn_cs_encoder * enc,const VkOffset2D * val)683 vn_encode_VkOffset2D(struct vn_cs_encoder *enc, const VkOffset2D *val)
684 {
685 vn_encode_int32_t(enc, &val->x);
686 vn_encode_int32_t(enc, &val->y);
687 }
688
689 static inline void
vn_decode_VkOffset2D(struct vn_cs_decoder * dec,VkOffset2D * val)690 vn_decode_VkOffset2D(struct vn_cs_decoder *dec, VkOffset2D *val)
691 {
692 vn_decode_int32_t(dec, &val->x);
693 vn_decode_int32_t(dec, &val->y);
694 }
695
696 static inline size_t
vn_sizeof_VkOffset2D_partial(const VkOffset2D * val)697 vn_sizeof_VkOffset2D_partial(const VkOffset2D *val)
698 {
699 size_t size = 0;
700 /* skip val->x */
701 /* skip val->y */
702 return size;
703 }
704
705 static inline void
vn_encode_VkOffset2D_partial(struct vn_cs_encoder * enc,const VkOffset2D * val)706 vn_encode_VkOffset2D_partial(struct vn_cs_encoder *enc, const VkOffset2D *val)
707 {
708 /* skip val->x */
709 /* skip val->y */
710 }
711
712 /* struct VkExtent2D */
713
714 static inline size_t
vn_sizeof_VkExtent2D(const VkExtent2D * val)715 vn_sizeof_VkExtent2D(const VkExtent2D *val)
716 {
717 size_t size = 0;
718 size += vn_sizeof_uint32_t(&val->width);
719 size += vn_sizeof_uint32_t(&val->height);
720 return size;
721 }
722
723 static inline void
vn_encode_VkExtent2D(struct vn_cs_encoder * enc,const VkExtent2D * val)724 vn_encode_VkExtent2D(struct vn_cs_encoder *enc, const VkExtent2D *val)
725 {
726 vn_encode_uint32_t(enc, &val->width);
727 vn_encode_uint32_t(enc, &val->height);
728 }
729
730 static inline void
vn_decode_VkExtent2D(struct vn_cs_decoder * dec,VkExtent2D * val)731 vn_decode_VkExtent2D(struct vn_cs_decoder *dec, VkExtent2D *val)
732 {
733 vn_decode_uint32_t(dec, &val->width);
734 vn_decode_uint32_t(dec, &val->height);
735 }
736
737 static inline size_t
vn_sizeof_VkExtent2D_partial(const VkExtent2D * val)738 vn_sizeof_VkExtent2D_partial(const VkExtent2D *val)
739 {
740 size_t size = 0;
741 /* skip val->width */
742 /* skip val->height */
743 return size;
744 }
745
746 static inline void
vn_encode_VkExtent2D_partial(struct vn_cs_encoder * enc,const VkExtent2D * val)747 vn_encode_VkExtent2D_partial(struct vn_cs_encoder *enc, const VkExtent2D *val)
748 {
749 /* skip val->width */
750 /* skip val->height */
751 }
752
753 /* struct VkRect2D */
754
755 static inline size_t
vn_sizeof_VkRect2D(const VkRect2D * val)756 vn_sizeof_VkRect2D(const VkRect2D *val)
757 {
758 size_t size = 0;
759 size += vn_sizeof_VkOffset2D(&val->offset);
760 size += vn_sizeof_VkExtent2D(&val->extent);
761 return size;
762 }
763
764 static inline void
vn_encode_VkRect2D(struct vn_cs_encoder * enc,const VkRect2D * val)765 vn_encode_VkRect2D(struct vn_cs_encoder *enc, const VkRect2D *val)
766 {
767 vn_encode_VkOffset2D(enc, &val->offset);
768 vn_encode_VkExtent2D(enc, &val->extent);
769 }
770
771 static inline void
vn_decode_VkRect2D(struct vn_cs_decoder * dec,VkRect2D * val)772 vn_decode_VkRect2D(struct vn_cs_decoder *dec, VkRect2D *val)
773 {
774 vn_decode_VkOffset2D(dec, &val->offset);
775 vn_decode_VkExtent2D(dec, &val->extent);
776 }
777
778 static inline size_t
vn_sizeof_VkRect2D_partial(const VkRect2D * val)779 vn_sizeof_VkRect2D_partial(const VkRect2D *val)
780 {
781 size_t size = 0;
782 size += vn_sizeof_VkOffset2D_partial(&val->offset);
783 size += vn_sizeof_VkExtent2D_partial(&val->extent);
784 return size;
785 }
786
787 static inline void
vn_encode_VkRect2D_partial(struct vn_cs_encoder * enc,const VkRect2D * val)788 vn_encode_VkRect2D_partial(struct vn_cs_encoder *enc, const VkRect2D *val)
789 {
790 vn_encode_VkOffset2D_partial(enc, &val->offset);
791 vn_encode_VkExtent2D_partial(enc, &val->extent);
792 }
793
794 /* union VkClearColorValue */
795
796 static inline size_t
vn_sizeof_VkClearColorValue_tag(const VkClearColorValue * val,uint32_t tag)797 vn_sizeof_VkClearColorValue_tag(const VkClearColorValue *val, uint32_t tag)
798 {
799 size_t size = vn_sizeof_uint32_t(&tag);
800 switch (tag) {
801 case 0:
802 size += vn_sizeof_array_size(4);
803 size += vn_sizeof_float_array(val->float32, 4);
804 break;
805 case 1:
806 size += vn_sizeof_array_size(4);
807 size += vn_sizeof_int32_t_array(val->int32, 4);
808 break;
809 case 2:
810 size += vn_sizeof_array_size(4);
811 size += vn_sizeof_uint32_t_array(val->uint32, 4);
812 break;
813 default:
814 assert(false);
815 break;
816 }
817 return size;
818 }
819
820 static inline size_t
vn_sizeof_VkClearColorValue(const VkClearColorValue * val)821 vn_sizeof_VkClearColorValue(const VkClearColorValue *val)
822 {
823 return vn_sizeof_VkClearColorValue_tag(val, 2);
824 }
825
826 static inline void
vn_encode_VkClearColorValue_tag(struct vn_cs_encoder * enc,const VkClearColorValue * val,uint32_t tag)827 vn_encode_VkClearColorValue_tag(struct vn_cs_encoder *enc, const VkClearColorValue *val, uint32_t tag)
828 {
829 vn_encode_uint32_t(enc, &tag);
830 switch (tag) {
831 case 0:
832 vn_encode_array_size(enc, 4);
833 vn_encode_float_array(enc, val->float32, 4);
834 break;
835 case 1:
836 vn_encode_array_size(enc, 4);
837 vn_encode_int32_t_array(enc, val->int32, 4);
838 break;
839 case 2:
840 vn_encode_array_size(enc, 4);
841 vn_encode_uint32_t_array(enc, val->uint32, 4);
842 break;
843 default:
844 assert(false);
845 break;
846 }
847 }
848
849 static inline void
vn_encode_VkClearColorValue(struct vn_cs_encoder * enc,const VkClearColorValue * val)850 vn_encode_VkClearColorValue(struct vn_cs_encoder *enc, const VkClearColorValue *val)
851 {
852 vn_encode_VkClearColorValue_tag(enc, val, 2); /* union with default tag */
853 }
854
855 /* struct VkMutableDescriptorTypeListEXT */
856
857 static inline size_t
vn_sizeof_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT * val)858 vn_sizeof_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT *val)
859 {
860 size_t size = 0;
861 size += vn_sizeof_uint32_t(&val->descriptorTypeCount);
862 if (val->pDescriptorTypes) {
863 size += vn_sizeof_array_size(val->descriptorTypeCount);
864 size += vn_sizeof_VkDescriptorType_array(val->pDescriptorTypes, val->descriptorTypeCount);
865 } else {
866 size += vn_sizeof_array_size(0);
867 }
868 return size;
869 }
870
871 static inline void
vn_encode_VkMutableDescriptorTypeListEXT(struct vn_cs_encoder * enc,const VkMutableDescriptorTypeListEXT * val)872 vn_encode_VkMutableDescriptorTypeListEXT(struct vn_cs_encoder *enc, const VkMutableDescriptorTypeListEXT *val)
873 {
874 vn_encode_uint32_t(enc, &val->descriptorTypeCount);
875 if (val->pDescriptorTypes) {
876 vn_encode_array_size(enc, val->descriptorTypeCount);
877 vn_encode_VkDescriptorType_array(enc, val->pDescriptorTypes, val->descriptorTypeCount);
878 } else {
879 vn_encode_array_size(enc, 0);
880 }
881 }
882
883 /* struct VkMutableDescriptorTypeCreateInfoEXT chain */
884
885 static inline size_t
vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT_pnext(const void * val)886 vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT_pnext(const void *val)
887 {
888 /* no known/supported struct */
889 return vn_sizeof_simple_pointer(NULL);
890 }
891
892 static inline size_t
vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT_self(const VkMutableDescriptorTypeCreateInfoEXT * val)893 vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT_self(const VkMutableDescriptorTypeCreateInfoEXT *val)
894 {
895 size_t size = 0;
896 /* skip val->{sType,pNext} */
897 size += vn_sizeof_uint32_t(&val->mutableDescriptorTypeListCount);
898 if (val->pMutableDescriptorTypeLists) {
899 size += vn_sizeof_array_size(val->mutableDescriptorTypeListCount);
900 for (uint32_t i = 0; i < val->mutableDescriptorTypeListCount; i++)
901 size += vn_sizeof_VkMutableDescriptorTypeListEXT(&val->pMutableDescriptorTypeLists[i]);
902 } else {
903 size += vn_sizeof_array_size(0);
904 }
905 return size;
906 }
907
908 static inline size_t
vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT * val)909 vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT *val)
910 {
911 size_t size = 0;
912
913 size += vn_sizeof_VkStructureType(&val->sType);
914 size += vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT_pnext(val->pNext);
915 size += vn_sizeof_VkMutableDescriptorTypeCreateInfoEXT_self(val);
916
917 return size;
918 }
919
920 static inline void
vn_encode_VkMutableDescriptorTypeCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)921 vn_encode_VkMutableDescriptorTypeCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
922 {
923 /* no known/supported struct */
924 vn_encode_simple_pointer(enc, NULL);
925 }
926
927 static inline void
vn_encode_VkMutableDescriptorTypeCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkMutableDescriptorTypeCreateInfoEXT * val)928 vn_encode_VkMutableDescriptorTypeCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkMutableDescriptorTypeCreateInfoEXT *val)
929 {
930 /* skip val->{sType,pNext} */
931 vn_encode_uint32_t(enc, &val->mutableDescriptorTypeListCount);
932 if (val->pMutableDescriptorTypeLists) {
933 vn_encode_array_size(enc, val->mutableDescriptorTypeListCount);
934 for (uint32_t i = 0; i < val->mutableDescriptorTypeListCount; i++)
935 vn_encode_VkMutableDescriptorTypeListEXT(enc, &val->pMutableDescriptorTypeLists[i]);
936 } else {
937 vn_encode_array_size(enc, 0);
938 }
939 }
940
941 static inline void
vn_encode_VkMutableDescriptorTypeCreateInfoEXT(struct vn_cs_encoder * enc,const VkMutableDescriptorTypeCreateInfoEXT * val)942 vn_encode_VkMutableDescriptorTypeCreateInfoEXT(struct vn_cs_encoder *enc, const VkMutableDescriptorTypeCreateInfoEXT *val)
943 {
944 assert(val->sType == VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
945 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT });
946 vn_encode_VkMutableDescriptorTypeCreateInfoEXT_pnext(enc, val->pNext);
947 vn_encode_VkMutableDescriptorTypeCreateInfoEXT_self(enc, val);
948 }
949
950 /* struct VkDescriptorImageInfo */
951
952 static inline size_t
vn_sizeof_VkDescriptorImageInfo(const VkDescriptorImageInfo * val)953 vn_sizeof_VkDescriptorImageInfo(const VkDescriptorImageInfo *val)
954 {
955 size_t size = 0;
956 size += vn_sizeof_VkSampler(&val->sampler);
957 size += vn_sizeof_VkImageView(&val->imageView);
958 size += vn_sizeof_VkImageLayout(&val->imageLayout);
959 return size;
960 }
961
962 static inline void
vn_encode_VkDescriptorImageInfo(struct vn_cs_encoder * enc,const VkDescriptorImageInfo * val)963 vn_encode_VkDescriptorImageInfo(struct vn_cs_encoder *enc, const VkDescriptorImageInfo *val)
964 {
965 vn_encode_VkSampler(enc, &val->sampler);
966 vn_encode_VkImageView(enc, &val->imageView);
967 vn_encode_VkImageLayout(enc, &val->imageLayout);
968 }
969
970 /* struct VkDescriptorBufferInfo */
971
972 static inline size_t
vn_sizeof_VkDescriptorBufferInfo(const VkDescriptorBufferInfo * val)973 vn_sizeof_VkDescriptorBufferInfo(const VkDescriptorBufferInfo *val)
974 {
975 size_t size = 0;
976 size += vn_sizeof_VkBuffer(&val->buffer);
977 size += vn_sizeof_VkDeviceSize(&val->offset);
978 size += vn_sizeof_VkDeviceSize(&val->range);
979 return size;
980 }
981
982 static inline void
vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder * enc,const VkDescriptorBufferInfo * val)983 vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder *enc, const VkDescriptorBufferInfo *val)
984 {
985 vn_encode_VkBuffer(enc, &val->buffer);
986 vn_encode_VkDeviceSize(enc, &val->offset);
987 vn_encode_VkDeviceSize(enc, &val->range);
988 }
989
990 /* struct VkWriteDescriptorSetInlineUniformBlock chain */
991
992 static inline size_t
vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_pnext(const void * val)993 vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_pnext(const void *val)
994 {
995 /* no known/supported struct */
996 return vn_sizeof_simple_pointer(NULL);
997 }
998
999 static inline size_t
vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self(const VkWriteDescriptorSetInlineUniformBlock * val)1000 vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self(const VkWriteDescriptorSetInlineUniformBlock *val)
1001 {
1002 size_t size = 0;
1003 /* skip val->{sType,pNext} */
1004 size += vn_sizeof_uint32_t(&val->dataSize);
1005 if (val->pData) {
1006 size += vn_sizeof_array_size(val->dataSize);
1007 size += vn_sizeof_blob_array(val->pData, val->dataSize);
1008 } else {
1009 size += vn_sizeof_array_size(0);
1010 }
1011 return size;
1012 }
1013
1014 static inline size_t
vn_sizeof_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock * val)1015 vn_sizeof_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock *val)
1016 {
1017 size_t size = 0;
1018
1019 size += vn_sizeof_VkStructureType(&val->sType);
1020 size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_pnext(val->pNext);
1021 size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self(val);
1022
1023 return size;
1024 }
1025
1026 static inline void
vn_encode_VkWriteDescriptorSetInlineUniformBlock_pnext(struct vn_cs_encoder * enc,const void * val)1027 vn_encode_VkWriteDescriptorSetInlineUniformBlock_pnext(struct vn_cs_encoder *enc, const void *val)
1028 {
1029 /* no known/supported struct */
1030 vn_encode_simple_pointer(enc, NULL);
1031 }
1032
1033 static inline void
vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(struct vn_cs_encoder * enc,const VkWriteDescriptorSetInlineUniformBlock * val)1034 vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSetInlineUniformBlock *val)
1035 {
1036 /* skip val->{sType,pNext} */
1037 vn_encode_uint32_t(enc, &val->dataSize);
1038 if (val->pData) {
1039 vn_encode_array_size(enc, val->dataSize);
1040 vn_encode_blob_array(enc, val->pData, val->dataSize);
1041 } else {
1042 vn_encode_array_size(enc, 0);
1043 }
1044 }
1045
1046 static inline void
vn_encode_VkWriteDescriptorSetInlineUniformBlock(struct vn_cs_encoder * enc,const VkWriteDescriptorSetInlineUniformBlock * val)1047 vn_encode_VkWriteDescriptorSetInlineUniformBlock(struct vn_cs_encoder *enc, const VkWriteDescriptorSetInlineUniformBlock *val)
1048 {
1049 assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK);
1050 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK });
1051 vn_encode_VkWriteDescriptorSetInlineUniformBlock_pnext(enc, val->pNext);
1052 vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(enc, val);
1053 }
1054
1055 /* struct VkWriteDescriptorSet chain */
1056
1057 static inline size_t
vn_sizeof_VkWriteDescriptorSet_pnext(const void * val)1058 vn_sizeof_VkWriteDescriptorSet_pnext(const void *val)
1059 {
1060 const VkBaseInStructure *pnext = val;
1061 size_t size = 0;
1062
1063 while (pnext) {
1064 switch ((int32_t)pnext->sType) {
1065 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
1066 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
1067 break;
1068 size += vn_sizeof_simple_pointer(pnext);
1069 size += vn_sizeof_VkStructureType(&pnext->sType);
1070 size += vn_sizeof_VkWriteDescriptorSet_pnext(pnext->pNext);
1071 size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self((const VkWriteDescriptorSetInlineUniformBlock *)pnext);
1072 return size;
1073 default:
1074 /* ignore unknown/unsupported struct */
1075 break;
1076 }
1077 pnext = pnext->pNext;
1078 }
1079
1080 return vn_sizeof_simple_pointer(NULL);
1081 }
1082
1083 static inline size_t
vn_sizeof_VkWriteDescriptorSet_self(const VkWriteDescriptorSet * val)1084 vn_sizeof_VkWriteDescriptorSet_self(const VkWriteDescriptorSet *val)
1085 {
1086 size_t size = 0;
1087 /* skip val->{sType,pNext} */
1088 size += vn_sizeof_VkDescriptorSet(&val->dstSet);
1089 size += vn_sizeof_uint32_t(&val->dstBinding);
1090 size += vn_sizeof_uint32_t(&val->dstArrayElement);
1091 size += vn_sizeof_uint32_t(&val->descriptorCount);
1092 size += vn_sizeof_VkDescriptorType(&val->descriptorType);
1093 if (val->pImageInfo) {
1094 size += vn_sizeof_array_size(val->descriptorCount);
1095 for (uint32_t i = 0; i < val->descriptorCount; i++)
1096 size += vn_sizeof_VkDescriptorImageInfo(&val->pImageInfo[i]);
1097 } else {
1098 size += vn_sizeof_array_size(0);
1099 }
1100 if (val->pBufferInfo) {
1101 size += vn_sizeof_array_size(val->descriptorCount);
1102 for (uint32_t i = 0; i < val->descriptorCount; i++)
1103 size += vn_sizeof_VkDescriptorBufferInfo(&val->pBufferInfo[i]);
1104 } else {
1105 size += vn_sizeof_array_size(0);
1106 }
1107 if (val->pTexelBufferView) {
1108 size += vn_sizeof_array_size(val->descriptorCount);
1109 for (uint32_t i = 0; i < val->descriptorCount; i++)
1110 size += vn_sizeof_VkBufferView(&val->pTexelBufferView[i]);
1111 } else {
1112 size += vn_sizeof_array_size(0);
1113 }
1114 return size;
1115 }
1116
1117 static inline size_t
vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet * val)1118 vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet *val)
1119 {
1120 size_t size = 0;
1121
1122 size += vn_sizeof_VkStructureType(&val->sType);
1123 size += vn_sizeof_VkWriteDescriptorSet_pnext(val->pNext);
1124 size += vn_sizeof_VkWriteDescriptorSet_self(val);
1125
1126 return size;
1127 }
1128
1129 static inline void
vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder * enc,const void * val)1130 vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
1131 {
1132 const VkBaseInStructure *pnext = val;
1133
1134 while (pnext) {
1135 switch ((int32_t)pnext->sType) {
1136 case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
1137 if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
1138 break;
1139 vn_encode_simple_pointer(enc, pnext);
1140 vn_encode_VkStructureType(enc, &pnext->sType);
1141 vn_encode_VkWriteDescriptorSet_pnext(enc, pnext->pNext);
1142 vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(enc, (const VkWriteDescriptorSetInlineUniformBlock *)pnext);
1143 return;
1144 default:
1145 /* ignore unknown/unsupported struct */
1146 break;
1147 }
1148 pnext = pnext->pNext;
1149 }
1150
1151 vn_encode_simple_pointer(enc, NULL);
1152 }
1153
1154 static inline void
vn_encode_VkWriteDescriptorSet_self(struct vn_cs_encoder * enc,const VkWriteDescriptorSet * val)1155 vn_encode_VkWriteDescriptorSet_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
1156 {
1157 /* skip val->{sType,pNext} */
1158 vn_encode_VkDescriptorSet(enc, &val->dstSet);
1159 vn_encode_uint32_t(enc, &val->dstBinding);
1160 vn_encode_uint32_t(enc, &val->dstArrayElement);
1161 vn_encode_uint32_t(enc, &val->descriptorCount);
1162 vn_encode_VkDescriptorType(enc, &val->descriptorType);
1163 if (val->pImageInfo) {
1164 vn_encode_array_size(enc, val->descriptorCount);
1165 for (uint32_t i = 0; i < val->descriptorCount; i++)
1166 vn_encode_VkDescriptorImageInfo(enc, &val->pImageInfo[i]);
1167 } else {
1168 vn_encode_array_size(enc, 0);
1169 }
1170 if (val->pBufferInfo) {
1171 vn_encode_array_size(enc, val->descriptorCount);
1172 for (uint32_t i = 0; i < val->descriptorCount; i++)
1173 vn_encode_VkDescriptorBufferInfo(enc, &val->pBufferInfo[i]);
1174 } else {
1175 vn_encode_array_size(enc, 0);
1176 }
1177 if (val->pTexelBufferView) {
1178 vn_encode_array_size(enc, val->descriptorCount);
1179 for (uint32_t i = 0; i < val->descriptorCount; i++)
1180 vn_encode_VkBufferView(enc, &val->pTexelBufferView[i]);
1181 } else {
1182 vn_encode_array_size(enc, 0);
1183 }
1184 }
1185
1186 static inline void
vn_encode_VkWriteDescriptorSet(struct vn_cs_encoder * enc,const VkWriteDescriptorSet * val)1187 vn_encode_VkWriteDescriptorSet(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
1188 {
1189 assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET);
1190 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET });
1191 vn_encode_VkWriteDescriptorSet_pnext(enc, val->pNext);
1192 vn_encode_VkWriteDescriptorSet_self(enc, val);
1193 }
1194
1195 /* struct VkMemoryDedicatedRequirements chain */
1196
1197 static inline size_t
vn_sizeof_VkMemoryDedicatedRequirements_pnext(const void * val)1198 vn_sizeof_VkMemoryDedicatedRequirements_pnext(const void *val)
1199 {
1200 /* no known/supported struct */
1201 return vn_sizeof_simple_pointer(NULL);
1202 }
1203
1204 static inline size_t
vn_sizeof_VkMemoryDedicatedRequirements_self(const VkMemoryDedicatedRequirements * val)1205 vn_sizeof_VkMemoryDedicatedRequirements_self(const VkMemoryDedicatedRequirements *val)
1206 {
1207 size_t size = 0;
1208 /* skip val->{sType,pNext} */
1209 size += vn_sizeof_VkBool32(&val->prefersDedicatedAllocation);
1210 size += vn_sizeof_VkBool32(&val->requiresDedicatedAllocation);
1211 return size;
1212 }
1213
1214 static inline size_t
vn_sizeof_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements * val)1215 vn_sizeof_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements *val)
1216 {
1217 size_t size = 0;
1218
1219 size += vn_sizeof_VkStructureType(&val->sType);
1220 size += vn_sizeof_VkMemoryDedicatedRequirements_pnext(val->pNext);
1221 size += vn_sizeof_VkMemoryDedicatedRequirements_self(val);
1222
1223 return size;
1224 }
1225
1226 static inline void
vn_decode_VkMemoryDedicatedRequirements_pnext(struct vn_cs_decoder * dec,const void * val)1227 vn_decode_VkMemoryDedicatedRequirements_pnext(struct vn_cs_decoder *dec, const void *val)
1228 {
1229 /* no known/supported struct */
1230 if (vn_decode_simple_pointer(dec))
1231 assert(false);
1232 }
1233
1234 static inline void
vn_decode_VkMemoryDedicatedRequirements_self(struct vn_cs_decoder * dec,VkMemoryDedicatedRequirements * val)1235 vn_decode_VkMemoryDedicatedRequirements_self(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val)
1236 {
1237 /* skip val->{sType,pNext} */
1238 vn_decode_VkBool32(dec, &val->prefersDedicatedAllocation);
1239 vn_decode_VkBool32(dec, &val->requiresDedicatedAllocation);
1240 }
1241
1242 static inline void
vn_decode_VkMemoryDedicatedRequirements(struct vn_cs_decoder * dec,VkMemoryDedicatedRequirements * val)1243 vn_decode_VkMemoryDedicatedRequirements(struct vn_cs_decoder *dec, VkMemoryDedicatedRequirements *val)
1244 {
1245 VkStructureType stype;
1246 vn_decode_VkStructureType(dec, &stype);
1247 assert(stype == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
1248
1249 assert(val->sType == stype);
1250 vn_decode_VkMemoryDedicatedRequirements_pnext(dec, val->pNext);
1251 vn_decode_VkMemoryDedicatedRequirements_self(dec, val);
1252 }
1253
1254 static inline size_t
vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(const void * val)1255 vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(const void *val)
1256 {
1257 /* no known/supported struct */
1258 return vn_sizeof_simple_pointer(NULL);
1259 }
1260
1261 static inline size_t
vn_sizeof_VkMemoryDedicatedRequirements_self_partial(const VkMemoryDedicatedRequirements * val)1262 vn_sizeof_VkMemoryDedicatedRequirements_self_partial(const VkMemoryDedicatedRequirements *val)
1263 {
1264 size_t size = 0;
1265 /* skip val->{sType,pNext} */
1266 /* skip val->prefersDedicatedAllocation */
1267 /* skip val->requiresDedicatedAllocation */
1268 return size;
1269 }
1270
1271 static inline size_t
vn_sizeof_VkMemoryDedicatedRequirements_partial(const VkMemoryDedicatedRequirements * val)1272 vn_sizeof_VkMemoryDedicatedRequirements_partial(const VkMemoryDedicatedRequirements *val)
1273 {
1274 size_t size = 0;
1275
1276 size += vn_sizeof_VkStructureType(&val->sType);
1277 size += vn_sizeof_VkMemoryDedicatedRequirements_pnext_partial(val->pNext);
1278 size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial(val);
1279
1280 return size;
1281 }
1282
1283 static inline void
vn_encode_VkMemoryDedicatedRequirements_pnext_partial(struct vn_cs_encoder * enc,const void * val)1284 vn_encode_VkMemoryDedicatedRequirements_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1285 {
1286 /* no known/supported struct */
1287 vn_encode_simple_pointer(enc, NULL);
1288 }
1289
1290 static inline void
vn_encode_VkMemoryDedicatedRequirements_self_partial(struct vn_cs_encoder * enc,const VkMemoryDedicatedRequirements * val)1291 vn_encode_VkMemoryDedicatedRequirements_self_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val)
1292 {
1293 /* skip val->{sType,pNext} */
1294 /* skip val->prefersDedicatedAllocation */
1295 /* skip val->requiresDedicatedAllocation */
1296 }
1297
1298 static inline void
vn_encode_VkMemoryDedicatedRequirements_partial(struct vn_cs_encoder * enc,const VkMemoryDedicatedRequirements * val)1299 vn_encode_VkMemoryDedicatedRequirements_partial(struct vn_cs_encoder *enc, const VkMemoryDedicatedRequirements *val)
1300 {
1301 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
1302 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS });
1303 vn_encode_VkMemoryDedicatedRequirements_pnext_partial(enc, val->pNext);
1304 vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, val);
1305 }
1306
1307 /* struct VkMemoryRequirements2 chain */
1308
1309 static inline size_t
vn_sizeof_VkMemoryRequirements2_pnext(const void * val)1310 vn_sizeof_VkMemoryRequirements2_pnext(const void *val)
1311 {
1312 const VkBaseInStructure *pnext = val;
1313 size_t size = 0;
1314
1315 while (pnext) {
1316 switch ((int32_t)pnext->sType) {
1317 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
1318 size += vn_sizeof_simple_pointer(pnext);
1319 size += vn_sizeof_VkStructureType(&pnext->sType);
1320 size += vn_sizeof_VkMemoryRequirements2_pnext(pnext->pNext);
1321 size += vn_sizeof_VkMemoryDedicatedRequirements_self((const VkMemoryDedicatedRequirements *)pnext);
1322 return size;
1323 default:
1324 /* ignore unknown/unsupported struct */
1325 break;
1326 }
1327 pnext = pnext->pNext;
1328 }
1329
1330 return vn_sizeof_simple_pointer(NULL);
1331 }
1332
1333 static inline size_t
vn_sizeof_VkMemoryRequirements2_self(const VkMemoryRequirements2 * val)1334 vn_sizeof_VkMemoryRequirements2_self(const VkMemoryRequirements2 *val)
1335 {
1336 size_t size = 0;
1337 /* skip val->{sType,pNext} */
1338 size += vn_sizeof_VkMemoryRequirements(&val->memoryRequirements);
1339 return size;
1340 }
1341
1342 static inline size_t
vn_sizeof_VkMemoryRequirements2(const VkMemoryRequirements2 * val)1343 vn_sizeof_VkMemoryRequirements2(const VkMemoryRequirements2 *val)
1344 {
1345 size_t size = 0;
1346
1347 size += vn_sizeof_VkStructureType(&val->sType);
1348 size += vn_sizeof_VkMemoryRequirements2_pnext(val->pNext);
1349 size += vn_sizeof_VkMemoryRequirements2_self(val);
1350
1351 return size;
1352 }
1353
1354 static inline void
vn_decode_VkMemoryRequirements2_pnext(struct vn_cs_decoder * dec,const void * val)1355 vn_decode_VkMemoryRequirements2_pnext(struct vn_cs_decoder *dec, const void *val)
1356 {
1357 VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
1358 VkStructureType stype;
1359
1360 if (!vn_decode_simple_pointer(dec))
1361 return;
1362
1363 vn_decode_VkStructureType(dec, &stype);
1364 while (true) {
1365 assert(pnext);
1366 if (pnext->sType == stype)
1367 break;
1368
1369 pnext = pnext->pNext;
1370 }
1371
1372 switch ((int32_t)pnext->sType) {
1373 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
1374 vn_decode_VkMemoryRequirements2_pnext(dec, pnext->pNext);
1375 vn_decode_VkMemoryDedicatedRequirements_self(dec, (VkMemoryDedicatedRequirements *)pnext);
1376 break;
1377 default:
1378 assert(false);
1379 break;
1380 }
1381 }
1382
1383 static inline void
vn_decode_VkMemoryRequirements2_self(struct vn_cs_decoder * dec,VkMemoryRequirements2 * val)1384 vn_decode_VkMemoryRequirements2_self(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val)
1385 {
1386 /* skip val->{sType,pNext} */
1387 vn_decode_VkMemoryRequirements(dec, &val->memoryRequirements);
1388 }
1389
1390 static inline void
vn_decode_VkMemoryRequirements2(struct vn_cs_decoder * dec,VkMemoryRequirements2 * val)1391 vn_decode_VkMemoryRequirements2(struct vn_cs_decoder *dec, VkMemoryRequirements2 *val)
1392 {
1393 VkStructureType stype;
1394 vn_decode_VkStructureType(dec, &stype);
1395 assert(stype == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
1396
1397 assert(val->sType == stype);
1398 vn_decode_VkMemoryRequirements2_pnext(dec, val->pNext);
1399 vn_decode_VkMemoryRequirements2_self(dec, val);
1400 }
1401
1402 static inline size_t
vn_sizeof_VkMemoryRequirements2_pnext_partial(const void * val)1403 vn_sizeof_VkMemoryRequirements2_pnext_partial(const void *val)
1404 {
1405 const VkBaseInStructure *pnext = val;
1406 size_t size = 0;
1407
1408 while (pnext) {
1409 switch ((int32_t)pnext->sType) {
1410 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
1411 size += vn_sizeof_simple_pointer(pnext);
1412 size += vn_sizeof_VkStructureType(&pnext->sType);
1413 size += vn_sizeof_VkMemoryRequirements2_pnext_partial(pnext->pNext);
1414 size += vn_sizeof_VkMemoryDedicatedRequirements_self_partial((const VkMemoryDedicatedRequirements *)pnext);
1415 return size;
1416 default:
1417 /* ignore unknown/unsupported struct */
1418 break;
1419 }
1420 pnext = pnext->pNext;
1421 }
1422
1423 return vn_sizeof_simple_pointer(NULL);
1424 }
1425
1426 static inline size_t
vn_sizeof_VkMemoryRequirements2_self_partial(const VkMemoryRequirements2 * val)1427 vn_sizeof_VkMemoryRequirements2_self_partial(const VkMemoryRequirements2 *val)
1428 {
1429 size_t size = 0;
1430 /* skip val->{sType,pNext} */
1431 size += vn_sizeof_VkMemoryRequirements_partial(&val->memoryRequirements);
1432 return size;
1433 }
1434
1435 static inline size_t
vn_sizeof_VkMemoryRequirements2_partial(const VkMemoryRequirements2 * val)1436 vn_sizeof_VkMemoryRequirements2_partial(const VkMemoryRequirements2 *val)
1437 {
1438 size_t size = 0;
1439
1440 size += vn_sizeof_VkStructureType(&val->sType);
1441 size += vn_sizeof_VkMemoryRequirements2_pnext_partial(val->pNext);
1442 size += vn_sizeof_VkMemoryRequirements2_self_partial(val);
1443
1444 return size;
1445 }
1446
1447 static inline void
vn_encode_VkMemoryRequirements2_pnext_partial(struct vn_cs_encoder * enc,const void * val)1448 vn_encode_VkMemoryRequirements2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1449 {
1450 const VkBaseInStructure *pnext = val;
1451
1452 while (pnext) {
1453 switch ((int32_t)pnext->sType) {
1454 case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
1455 vn_encode_simple_pointer(enc, pnext);
1456 vn_encode_VkStructureType(enc, &pnext->sType);
1457 vn_encode_VkMemoryRequirements2_pnext_partial(enc, pnext->pNext);
1458 vn_encode_VkMemoryDedicatedRequirements_self_partial(enc, (const VkMemoryDedicatedRequirements *)pnext);
1459 return;
1460 default:
1461 /* ignore unknown/unsupported struct */
1462 break;
1463 }
1464 pnext = pnext->pNext;
1465 }
1466
1467 vn_encode_simple_pointer(enc, NULL);
1468 }
1469
1470 static inline void
vn_encode_VkMemoryRequirements2_self_partial(struct vn_cs_encoder * enc,const VkMemoryRequirements2 * val)1471 vn_encode_VkMemoryRequirements2_self_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val)
1472 {
1473 /* skip val->{sType,pNext} */
1474 vn_encode_VkMemoryRequirements_partial(enc, &val->memoryRequirements);
1475 }
1476
1477 static inline void
vn_encode_VkMemoryRequirements2_partial(struct vn_cs_encoder * enc,const VkMemoryRequirements2 * val)1478 vn_encode_VkMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkMemoryRequirements2 *val)
1479 {
1480 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
1481 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 });
1482 vn_encode_VkMemoryRequirements2_pnext_partial(enc, val->pNext);
1483 vn_encode_VkMemoryRequirements2_self_partial(enc, val);
1484 }
1485
1486 /* struct VkMemoryBarrier2 chain */
1487
1488 static inline size_t
vn_sizeof_VkMemoryBarrier2_pnext(const void * val)1489 vn_sizeof_VkMemoryBarrier2_pnext(const void *val)
1490 {
1491 /* no known/supported struct */
1492 return vn_sizeof_simple_pointer(NULL);
1493 }
1494
1495 static inline size_t
vn_sizeof_VkMemoryBarrier2_self(const VkMemoryBarrier2 * val)1496 vn_sizeof_VkMemoryBarrier2_self(const VkMemoryBarrier2 *val)
1497 {
1498 size_t size = 0;
1499 /* skip val->{sType,pNext} */
1500 size += vn_sizeof_VkFlags64(&val->srcStageMask);
1501 size += vn_sizeof_VkFlags64(&val->srcAccessMask);
1502 size += vn_sizeof_VkFlags64(&val->dstStageMask);
1503 size += vn_sizeof_VkFlags64(&val->dstAccessMask);
1504 return size;
1505 }
1506
1507 static inline size_t
vn_sizeof_VkMemoryBarrier2(const VkMemoryBarrier2 * val)1508 vn_sizeof_VkMemoryBarrier2(const VkMemoryBarrier2 *val)
1509 {
1510 size_t size = 0;
1511
1512 size += vn_sizeof_VkStructureType(&val->sType);
1513 size += vn_sizeof_VkMemoryBarrier2_pnext(val->pNext);
1514 size += vn_sizeof_VkMemoryBarrier2_self(val);
1515
1516 return size;
1517 }
1518
1519 static inline void
vn_encode_VkMemoryBarrier2_pnext(struct vn_cs_encoder * enc,const void * val)1520 vn_encode_VkMemoryBarrier2_pnext(struct vn_cs_encoder *enc, const void *val)
1521 {
1522 /* no known/supported struct */
1523 vn_encode_simple_pointer(enc, NULL);
1524 }
1525
1526 static inline void
vn_encode_VkMemoryBarrier2_self(struct vn_cs_encoder * enc,const VkMemoryBarrier2 * val)1527 vn_encode_VkMemoryBarrier2_self(struct vn_cs_encoder *enc, const VkMemoryBarrier2 *val)
1528 {
1529 /* skip val->{sType,pNext} */
1530 vn_encode_VkFlags64(enc, &val->srcStageMask);
1531 vn_encode_VkFlags64(enc, &val->srcAccessMask);
1532 vn_encode_VkFlags64(enc, &val->dstStageMask);
1533 vn_encode_VkFlags64(enc, &val->dstAccessMask);
1534 }
1535
1536 static inline void
vn_encode_VkMemoryBarrier2(struct vn_cs_encoder * enc,const VkMemoryBarrier2 * val)1537 vn_encode_VkMemoryBarrier2(struct vn_cs_encoder *enc, const VkMemoryBarrier2 *val)
1538 {
1539 assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_BARRIER_2);
1540 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 });
1541 vn_encode_VkMemoryBarrier2_pnext(enc, val->pNext);
1542 vn_encode_VkMemoryBarrier2_self(enc, val);
1543 }
1544
1545 #endif /* VN_PROTOCOL_DRIVER_STRUCTS_H */
1546