• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_TYPES_H
9 #define VN_PROTOCOL_DRIVER_TYPES_H
10 
11 #include "vn_protocol_driver_cs.h"
12 #include "vn_protocol_driver_defines.h"
13 
14 /* uint64_t */
15 
16 static inline size_t
vn_sizeof_uint64_t(const uint64_t * val)17 vn_sizeof_uint64_t(const uint64_t *val)
18 {
19     assert(sizeof(*val) == 8);
20     return 8;
21 }
22 
23 static inline void
vn_encode_uint64_t(struct vn_cs_encoder * enc,const uint64_t * val)24 vn_encode_uint64_t(struct vn_cs_encoder *enc, const uint64_t *val)
25 {
26     vn_encode(enc, 8, val, sizeof(*val));
27 }
28 
29 static inline void
vn_decode_uint64_t(struct vn_cs_decoder * dec,uint64_t * val)30 vn_decode_uint64_t(struct vn_cs_decoder *dec, uint64_t *val)
31 {
32     vn_decode(dec, 8, val, sizeof(*val));
33 }
34 
35 static inline size_t
vn_sizeof_uint64_t_array(const uint64_t * val,uint32_t count)36 vn_sizeof_uint64_t_array(const uint64_t *val, uint32_t count)
37 {
38     assert(sizeof(*val) == 8);
39     const size_t size = sizeof(*val) * count;
40     assert(size >= count);
41     return size;
42 }
43 
44 static inline void
vn_encode_uint64_t_array(struct vn_cs_encoder * enc,const uint64_t * val,uint32_t count)45 vn_encode_uint64_t_array(struct vn_cs_encoder *enc, const uint64_t *val, uint32_t count)
46 {
47     const size_t size = sizeof(*val) * count;
48     assert(size >= count);
49     vn_encode(enc, size, val, size);
50 }
51 
52 static inline void
vn_decode_uint64_t_array(struct vn_cs_decoder * dec,uint64_t * val,uint32_t count)53 vn_decode_uint64_t_array(struct vn_cs_decoder *dec, uint64_t *val, uint32_t count)
54 {
55     const size_t size = sizeof(*val) * count;
56     assert(size >= count);
57     vn_decode(dec, size, val, size);
58 }
59 
60 /* int32_t */
61 
62 static inline size_t
vn_sizeof_int32_t(const int32_t * val)63 vn_sizeof_int32_t(const int32_t *val)
64 {
65     assert(sizeof(*val) == 4);
66     return 4;
67 }
68 
69 static inline void
vn_encode_int32_t(struct vn_cs_encoder * enc,const int32_t * val)70 vn_encode_int32_t(struct vn_cs_encoder *enc, const int32_t *val)
71 {
72     vn_encode(enc, 4, val, sizeof(*val));
73 }
74 
75 static inline void
vn_decode_int32_t(struct vn_cs_decoder * dec,int32_t * val)76 vn_decode_int32_t(struct vn_cs_decoder *dec, int32_t *val)
77 {
78     vn_decode(dec, 4, val, sizeof(*val));
79 }
80 
81 static inline size_t
vn_sizeof_int32_t_array(const int32_t * val,uint32_t count)82 vn_sizeof_int32_t_array(const int32_t *val, uint32_t count)
83 {
84     assert(sizeof(*val) == 4);
85     const size_t size = sizeof(*val) * count;
86     assert(size >= count);
87     return size;
88 }
89 
90 static inline void
vn_encode_int32_t_array(struct vn_cs_encoder * enc,const int32_t * val,uint32_t count)91 vn_encode_int32_t_array(struct vn_cs_encoder *enc, const int32_t *val, uint32_t count)
92 {
93     const size_t size = sizeof(*val) * count;
94     assert(size >= count);
95     vn_encode(enc, size, val, size);
96 }
97 
98 static inline void
vn_decode_int32_t_array(struct vn_cs_decoder * dec,int32_t * val,uint32_t count)99 vn_decode_int32_t_array(struct vn_cs_decoder *dec, int32_t *val, uint32_t count)
100 {
101     const size_t size = sizeof(*val) * count;
102     assert(size >= count);
103     vn_decode(dec, size, val, size);
104 }
105 
106 /* enum VkStructureType */
107 
108 static inline size_t
vn_sizeof_VkStructureType(const VkStructureType * val)109 vn_sizeof_VkStructureType(const VkStructureType *val)
110 {
111     assert(sizeof(*val) == sizeof(int32_t));
112     return vn_sizeof_int32_t((const int32_t *)val);
113 }
114 
115 static inline void
vn_encode_VkStructureType(struct vn_cs_encoder * enc,const VkStructureType * val)116 vn_encode_VkStructureType(struct vn_cs_encoder *enc, const VkStructureType *val)
117 {
118     vn_encode_int32_t(enc, (const int32_t *)val);
119 }
120 
121 static inline void
vn_decode_VkStructureType(struct vn_cs_decoder * dec,VkStructureType * val)122 vn_decode_VkStructureType(struct vn_cs_decoder *dec, VkStructureType *val)
123 {
124     vn_decode_int32_t(dec, (int32_t *)val);
125 }
126 
127 /* size_t */
128 
129 static inline size_t
vn_sizeof_size_t(const size_t * val)130 vn_sizeof_size_t(const size_t *val)
131 {
132     return vn_sizeof_uint64_t(&(uint64_t){ *val });
133 }
134 
135 static inline void
vn_encode_size_t(struct vn_cs_encoder * enc,const size_t * val)136 vn_encode_size_t(struct vn_cs_encoder *enc, const size_t *val)
137 {
138     const uint64_t tmp = *val;
139     vn_encode_uint64_t(enc, &tmp);
140 }
141 
142 static inline void
vn_decode_size_t(struct vn_cs_decoder * dec,size_t * val)143 vn_decode_size_t(struct vn_cs_decoder *dec, size_t *val)
144 {
145     uint64_t tmp;
146     vn_decode_uint64_t(dec, &tmp);
147     *val = tmp;
148 }
149 
150 static inline size_t
vn_sizeof_size_t_array(const size_t * val,uint32_t count)151 vn_sizeof_size_t_array(const size_t *val, uint32_t count)
152 {
153     return vn_sizeof_size_t(val) * count;
154 }
155 
156 static inline void
vn_encode_size_t_array(struct vn_cs_encoder * enc,const size_t * val,uint32_t count)157 vn_encode_size_t_array(struct vn_cs_encoder *enc, const size_t *val, uint32_t count)
158 {
159     if (sizeof(size_t) == sizeof(uint64_t)) {
160         vn_encode_uint64_t_array(enc, (const uint64_t *)val, count);
161     } else {
162         for (uint32_t i = 0; i < count; i++)
163             vn_encode_size_t(enc, &val[i]);
164     }
165 }
166 
167 static inline void
vn_decode_size_t_array(struct vn_cs_decoder * dec,size_t * val,uint32_t count)168 vn_decode_size_t_array(struct vn_cs_decoder *dec, size_t *val, uint32_t count)
169 {
170     if (sizeof(size_t) == sizeof(uint64_t)) {
171         vn_decode_uint64_t_array(dec, (uint64_t *)val, count);
172     } else {
173         for (uint32_t i = 0; i < count; i++)
174             vn_decode_size_t(dec, &val[i]);
175     }
176 }
177 
178 /* opaque blob */
179 
180 static inline size_t
vn_sizeof_blob_array(const void * val,size_t size)181 vn_sizeof_blob_array(const void *val, size_t size)
182 {
183     return (size + 3) & ~3;
184 }
185 
186 static inline void
vn_encode_blob_array(struct vn_cs_encoder * enc,const void * val,size_t size)187 vn_encode_blob_array(struct vn_cs_encoder *enc, const void *val, size_t size)
188 {
189     vn_encode(enc, (size + 3) & ~3, val, size);
190 }
191 
192 static inline void
vn_decode_blob_array(struct vn_cs_decoder * dec,void * val,size_t size)193 vn_decode_blob_array(struct vn_cs_decoder *dec, void *val, size_t size)
194 {
195     vn_decode(dec, (size + 3) & ~3, val, size);
196 }
197 
198 /* string */
199 
200 static inline size_t
vn_sizeof_char_array(const char * val,size_t size)201 vn_sizeof_char_array(const char *val, size_t size)
202 {
203     return vn_sizeof_blob_array(val, size);
204 }
205 
206 static inline void
vn_encode_char_array(struct vn_cs_encoder * enc,const char * val,size_t size)207 vn_encode_char_array(struct vn_cs_encoder *enc, const char *val, size_t size)
208 {
209     assert(size && strlen(val) < size);
210     vn_encode_blob_array(enc, val, size);
211 }
212 
213 static inline void
vn_decode_char_array(struct vn_cs_decoder * dec,char * val,size_t size)214 vn_decode_char_array(struct vn_cs_decoder *dec, char *val, size_t size)
215 {
216     vn_decode_blob_array(dec, val, size);
217     if (size)
218         val[size - 1] = '\0';
219     else
220         vn_cs_decoder_set_fatal(dec);
221 }
222 
223 /* array size (uint64_t) */
224 
225 static inline size_t
vn_sizeof_array_size(uint64_t size)226 vn_sizeof_array_size(uint64_t size)
227 {
228     return vn_sizeof_uint64_t(&size);
229 }
230 
231 static inline void
vn_encode_array_size(struct vn_cs_encoder * enc,uint64_t size)232 vn_encode_array_size(struct vn_cs_encoder *enc, uint64_t size)
233 {
234     vn_encode_uint64_t(enc, &size);
235 }
236 
237 static inline uint64_t
vn_decode_array_size(struct vn_cs_decoder * dec,uint64_t expected_size)238 vn_decode_array_size(struct vn_cs_decoder *dec, uint64_t expected_size)
239 {
240     uint64_t size;
241     vn_decode_uint64_t(dec, &size);
242     if (size != expected_size) {
243         vn_cs_decoder_set_fatal(dec);
244         size = 0;
245     }
246     return size;
247 }
248 
249 static inline uint64_t
vn_decode_array_size_unchecked(struct vn_cs_decoder * dec)250 vn_decode_array_size_unchecked(struct vn_cs_decoder *dec)
251 {
252     uint64_t size;
253     vn_decode_uint64_t(dec, &size);
254     return size;
255 }
256 
257 static inline uint64_t
vn_peek_array_size(struct vn_cs_decoder * dec)258 vn_peek_array_size(struct vn_cs_decoder *dec)
259 {
260     uint64_t size;
261     vn_cs_decoder_peek(dec, sizeof(size), &size, sizeof(size));
262     return size;
263 }
264 
265 /* non-array pointer */
266 
267 static inline size_t
vn_sizeof_simple_pointer(const void * val)268 vn_sizeof_simple_pointer(const void *val)
269 {
270     return vn_sizeof_array_size(val ? 1 : 0);
271 }
272 
273 static inline bool
vn_encode_simple_pointer(struct vn_cs_encoder * enc,const void * val)274 vn_encode_simple_pointer(struct vn_cs_encoder *enc, const void *val)
275 {
276     vn_encode_array_size(enc, val ? 1 : 0);
277     return val;
278 }
279 
280 static inline bool
vn_decode_simple_pointer(struct vn_cs_decoder * dec)281 vn_decode_simple_pointer(struct vn_cs_decoder *dec)
282 {
283     return vn_decode_array_size_unchecked(dec);
284 }
285 
286 /* uint32_t */
287 
288 static inline size_t
vn_sizeof_uint32_t(const uint32_t * val)289 vn_sizeof_uint32_t(const uint32_t *val)
290 {
291     assert(sizeof(*val) == 4);
292     return 4;
293 }
294 
295 static inline void
vn_encode_uint32_t(struct vn_cs_encoder * enc,const uint32_t * val)296 vn_encode_uint32_t(struct vn_cs_encoder *enc, const uint32_t *val)
297 {
298     vn_encode(enc, 4, val, sizeof(*val));
299 }
300 
301 static inline void
vn_decode_uint32_t(struct vn_cs_decoder * dec,uint32_t * val)302 vn_decode_uint32_t(struct vn_cs_decoder *dec, uint32_t *val)
303 {
304     vn_decode(dec, 4, val, sizeof(*val));
305 }
306 
307 static inline size_t
vn_sizeof_uint32_t_array(const uint32_t * val,uint32_t count)308 vn_sizeof_uint32_t_array(const uint32_t *val, uint32_t count)
309 {
310     assert(sizeof(*val) == 4);
311     const size_t size = sizeof(*val) * count;
312     assert(size >= count);
313     return size;
314 }
315 
316 static inline void
vn_encode_uint32_t_array(struct vn_cs_encoder * enc,const uint32_t * val,uint32_t count)317 vn_encode_uint32_t_array(struct vn_cs_encoder *enc, const uint32_t *val, uint32_t count)
318 {
319     const size_t size = sizeof(*val) * count;
320     assert(size >= count);
321     vn_encode(enc, size, val, size);
322 }
323 
324 static inline void
vn_decode_uint32_t_array(struct vn_cs_decoder * dec,uint32_t * val,uint32_t count)325 vn_decode_uint32_t_array(struct vn_cs_decoder *dec, uint32_t *val, uint32_t count)
326 {
327     const size_t size = sizeof(*val) * count;
328     assert(size >= count);
329     vn_decode(dec, size, val, size);
330 }
331 
332 /* float */
333 
334 static inline size_t
vn_sizeof_float(const float * val)335 vn_sizeof_float(const float *val)
336 {
337     assert(sizeof(*val) == 4);
338     return 4;
339 }
340 
341 static inline void
vn_encode_float(struct vn_cs_encoder * enc,const float * val)342 vn_encode_float(struct vn_cs_encoder *enc, const float *val)
343 {
344     vn_encode(enc, 4, val, sizeof(*val));
345 }
346 
347 static inline void
vn_decode_float(struct vn_cs_decoder * dec,float * val)348 vn_decode_float(struct vn_cs_decoder *dec, float *val)
349 {
350     vn_decode(dec, 4, val, sizeof(*val));
351 }
352 
353 static inline size_t
vn_sizeof_float_array(const float * val,uint32_t count)354 vn_sizeof_float_array(const float *val, uint32_t count)
355 {
356     assert(sizeof(*val) == 4);
357     const size_t size = sizeof(*val) * count;
358     assert(size >= count);
359     return size;
360 }
361 
362 static inline void
vn_encode_float_array(struct vn_cs_encoder * enc,const float * val,uint32_t count)363 vn_encode_float_array(struct vn_cs_encoder *enc, const float *val, uint32_t count)
364 {
365     const size_t size = sizeof(*val) * count;
366     assert(size >= count);
367     vn_encode(enc, size, val, size);
368 }
369 
370 static inline void
vn_decode_float_array(struct vn_cs_decoder * dec,float * val,uint32_t count)371 vn_decode_float_array(struct vn_cs_decoder *dec, float *val, uint32_t count)
372 {
373     const size_t size = sizeof(*val) * count;
374     assert(size >= count);
375     vn_decode(dec, size, val, size);
376 }
377 
378 /* uint8_t */
379 
380 static inline size_t
vn_sizeof_uint8_t(const uint8_t * val)381 vn_sizeof_uint8_t(const uint8_t *val)
382 {
383     assert(sizeof(*val) == 1);
384     return 4;
385 }
386 
387 static inline void
vn_encode_uint8_t(struct vn_cs_encoder * enc,const uint8_t * val)388 vn_encode_uint8_t(struct vn_cs_encoder *enc, const uint8_t *val)
389 {
390     vn_encode(enc, 4, val, sizeof(*val));
391 }
392 
393 static inline void
vn_decode_uint8_t(struct vn_cs_decoder * dec,uint8_t * val)394 vn_decode_uint8_t(struct vn_cs_decoder *dec, uint8_t *val)
395 {
396     vn_decode(dec, 4, val, sizeof(*val));
397 }
398 
399 static inline size_t
vn_sizeof_uint8_t_array(const uint8_t * val,uint32_t count)400 vn_sizeof_uint8_t_array(const uint8_t *val, uint32_t count)
401 {
402     assert(sizeof(*val) == 1);
403     const size_t size = sizeof(*val) * count;
404     assert(size >= count);
405     return (size + 3) & ~3;
406 }
407 
408 static inline void
vn_encode_uint8_t_array(struct vn_cs_encoder * enc,const uint8_t * val,uint32_t count)409 vn_encode_uint8_t_array(struct vn_cs_encoder *enc, const uint8_t *val, uint32_t count)
410 {
411     const size_t size = sizeof(*val) * count;
412     assert(size >= count);
413     vn_encode(enc, (size + 3) & ~3, val, size);
414 }
415 
416 static inline void
vn_decode_uint8_t_array(struct vn_cs_decoder * dec,uint8_t * val,uint32_t count)417 vn_decode_uint8_t_array(struct vn_cs_decoder *dec, uint8_t *val, uint32_t count)
418 {
419     const size_t size = sizeof(*val) * count;
420     assert(size >= count);
421     vn_decode(dec, (size + 3) & ~3, val, size);
422 }
423 
424 /* uint16_t */
425 
426 static inline size_t
vn_sizeof_uint16_t(const uint16_t * val)427 vn_sizeof_uint16_t(const uint16_t *val)
428 {
429     assert(sizeof(*val) == 2);
430     return 4;
431 }
432 
433 static inline void
vn_encode_uint16_t(struct vn_cs_encoder * enc,const uint16_t * val)434 vn_encode_uint16_t(struct vn_cs_encoder *enc, const uint16_t *val)
435 {
436     vn_encode(enc, 4, val, sizeof(*val));
437 }
438 
439 static inline void
vn_decode_uint16_t(struct vn_cs_decoder * dec,uint16_t * val)440 vn_decode_uint16_t(struct vn_cs_decoder *dec, uint16_t *val)
441 {
442     vn_decode(dec, 4, val, sizeof(*val));
443 }
444 
445 /* typedef uint32_t VkSampleMask */
446 
447 static inline size_t
vn_sizeof_VkSampleMask(const VkSampleMask * val)448 vn_sizeof_VkSampleMask(const VkSampleMask *val)
449 {
450     return vn_sizeof_uint32_t(val);
451 }
452 
453 static inline void
vn_encode_VkSampleMask(struct vn_cs_encoder * enc,const VkSampleMask * val)454 vn_encode_VkSampleMask(struct vn_cs_encoder *enc, const VkSampleMask *val)
455 {
456     vn_encode_uint32_t(enc, val);
457 }
458 
459 static inline void
vn_decode_VkSampleMask(struct vn_cs_decoder * dec,VkSampleMask * val)460 vn_decode_VkSampleMask(struct vn_cs_decoder *dec, VkSampleMask *val)
461 {
462     vn_decode_uint32_t(dec, val);
463 }
464 
465 static inline size_t
vn_sizeof_VkSampleMask_array(const VkSampleMask * val,uint32_t count)466 vn_sizeof_VkSampleMask_array(const VkSampleMask *val, uint32_t count)
467 {
468     return vn_sizeof_uint32_t_array(val, count);
469 }
470 
471 static inline void
vn_encode_VkSampleMask_array(struct vn_cs_encoder * enc,const VkSampleMask * val,uint32_t count)472 vn_encode_VkSampleMask_array(struct vn_cs_encoder *enc, const VkSampleMask *val, uint32_t count)
473 {
474     vn_encode_uint32_t_array(enc, val, count);
475 }
476 
477 static inline void
vn_decode_VkSampleMask_array(struct vn_cs_decoder * dec,VkSampleMask * val,uint32_t count)478 vn_decode_VkSampleMask_array(struct vn_cs_decoder *dec, VkSampleMask *val, uint32_t count)
479 {
480     vn_decode_uint32_t_array(dec, val, count);
481 }
482 
483 /* typedef uint32_t VkBool32 */
484 
485 static inline size_t
vn_sizeof_VkBool32(const VkBool32 * val)486 vn_sizeof_VkBool32(const VkBool32 *val)
487 {
488     return vn_sizeof_uint32_t(val);
489 }
490 
491 static inline void
vn_encode_VkBool32(struct vn_cs_encoder * enc,const VkBool32 * val)492 vn_encode_VkBool32(struct vn_cs_encoder *enc, const VkBool32 *val)
493 {
494     vn_encode_uint32_t(enc, val);
495 }
496 
497 static inline void
vn_decode_VkBool32(struct vn_cs_decoder * dec,VkBool32 * val)498 vn_decode_VkBool32(struct vn_cs_decoder *dec, VkBool32 *val)
499 {
500     vn_decode_uint32_t(dec, val);
501 }
502 
503 static inline size_t
vn_sizeof_VkBool32_array(const VkBool32 * val,uint32_t count)504 vn_sizeof_VkBool32_array(const VkBool32 *val, uint32_t count)
505 {
506     return vn_sizeof_uint32_t_array(val, count);
507 }
508 
509 static inline void
vn_encode_VkBool32_array(struct vn_cs_encoder * enc,const VkBool32 * val,uint32_t count)510 vn_encode_VkBool32_array(struct vn_cs_encoder *enc, const VkBool32 *val, uint32_t count)
511 {
512     vn_encode_uint32_t_array(enc, val, count);
513 }
514 
515 static inline void
vn_decode_VkBool32_array(struct vn_cs_decoder * dec,VkBool32 * val,uint32_t count)516 vn_decode_VkBool32_array(struct vn_cs_decoder *dec, VkBool32 *val, uint32_t count)
517 {
518     vn_decode_uint32_t_array(dec, val, count);
519 }
520 
521 /* typedef uint32_t VkFlags */
522 
523 static inline size_t
vn_sizeof_VkFlags(const VkFlags * val)524 vn_sizeof_VkFlags(const VkFlags *val)
525 {
526     return vn_sizeof_uint32_t(val);
527 }
528 
529 static inline void
vn_encode_VkFlags(struct vn_cs_encoder * enc,const VkFlags * val)530 vn_encode_VkFlags(struct vn_cs_encoder *enc, const VkFlags *val)
531 {
532     vn_encode_uint32_t(enc, val);
533 }
534 
535 static inline void
vn_decode_VkFlags(struct vn_cs_decoder * dec,VkFlags * val)536 vn_decode_VkFlags(struct vn_cs_decoder *dec, VkFlags *val)
537 {
538     vn_decode_uint32_t(dec, val);
539 }
540 
541 static inline size_t
vn_sizeof_VkFlags_array(const VkFlags * val,uint32_t count)542 vn_sizeof_VkFlags_array(const VkFlags *val, uint32_t count)
543 {
544     return vn_sizeof_uint32_t_array(val, count);
545 }
546 
547 static inline void
vn_encode_VkFlags_array(struct vn_cs_encoder * enc,const VkFlags * val,uint32_t count)548 vn_encode_VkFlags_array(struct vn_cs_encoder *enc, const VkFlags *val, uint32_t count)
549 {
550     vn_encode_uint32_t_array(enc, val, count);
551 }
552 
553 static inline void
vn_decode_VkFlags_array(struct vn_cs_decoder * dec,VkFlags * val,uint32_t count)554 vn_decode_VkFlags_array(struct vn_cs_decoder *dec, VkFlags *val, uint32_t count)
555 {
556     vn_decode_uint32_t_array(dec, val, count);
557 }
558 
559 /* typedef uint64_t VkFlags64 */
560 
561 static inline size_t
vn_sizeof_VkFlags64(const VkFlags64 * val)562 vn_sizeof_VkFlags64(const VkFlags64 *val)
563 {
564     return vn_sizeof_uint64_t(val);
565 }
566 
567 static inline void
vn_encode_VkFlags64(struct vn_cs_encoder * enc,const VkFlags64 * val)568 vn_encode_VkFlags64(struct vn_cs_encoder *enc, const VkFlags64 *val)
569 {
570     vn_encode_uint64_t(enc, val);
571 }
572 
573 static inline void
vn_decode_VkFlags64(struct vn_cs_decoder * dec,VkFlags64 * val)574 vn_decode_VkFlags64(struct vn_cs_decoder *dec, VkFlags64 *val)
575 {
576     vn_decode_uint64_t(dec, val);
577 }
578 
579 /* typedef uint64_t VkDeviceSize */
580 
581 static inline size_t
vn_sizeof_VkDeviceSize(const VkDeviceSize * val)582 vn_sizeof_VkDeviceSize(const VkDeviceSize *val)
583 {
584     return vn_sizeof_uint64_t(val);
585 }
586 
587 static inline void
vn_encode_VkDeviceSize(struct vn_cs_encoder * enc,const VkDeviceSize * val)588 vn_encode_VkDeviceSize(struct vn_cs_encoder *enc, const VkDeviceSize *val)
589 {
590     vn_encode_uint64_t(enc, val);
591 }
592 
593 static inline void
vn_decode_VkDeviceSize(struct vn_cs_decoder * dec,VkDeviceSize * val)594 vn_decode_VkDeviceSize(struct vn_cs_decoder *dec, VkDeviceSize *val)
595 {
596     vn_decode_uint64_t(dec, val);
597 }
598 
599 static inline size_t
vn_sizeof_VkDeviceSize_array(const VkDeviceSize * val,uint32_t count)600 vn_sizeof_VkDeviceSize_array(const VkDeviceSize *val, uint32_t count)
601 {
602     return vn_sizeof_uint64_t_array(val, count);
603 }
604 
605 static inline void
vn_encode_VkDeviceSize_array(struct vn_cs_encoder * enc,const VkDeviceSize * val,uint32_t count)606 vn_encode_VkDeviceSize_array(struct vn_cs_encoder *enc, const VkDeviceSize *val, uint32_t count)
607 {
608     vn_encode_uint64_t_array(enc, val, count);
609 }
610 
611 static inline void
vn_decode_VkDeviceSize_array(struct vn_cs_decoder * dec,VkDeviceSize * val,uint32_t count)612 vn_decode_VkDeviceSize_array(struct vn_cs_decoder *dec, VkDeviceSize *val, uint32_t count)
613 {
614     vn_decode_uint64_t_array(dec, val, count);
615 }
616 
617 /* typedef uint64_t VkDeviceAddress */
618 
619 static inline size_t
vn_sizeof_VkDeviceAddress(const VkDeviceAddress * val)620 vn_sizeof_VkDeviceAddress(const VkDeviceAddress *val)
621 {
622     return vn_sizeof_uint64_t(val);
623 }
624 
625 static inline void
vn_encode_VkDeviceAddress(struct vn_cs_encoder * enc,const VkDeviceAddress * val)626 vn_encode_VkDeviceAddress(struct vn_cs_encoder *enc, const VkDeviceAddress *val)
627 {
628     vn_encode_uint64_t(enc, val);
629 }
630 
631 static inline void
vn_decode_VkDeviceAddress(struct vn_cs_decoder * dec,VkDeviceAddress * val)632 vn_decode_VkDeviceAddress(struct vn_cs_decoder *dec, VkDeviceAddress *val)
633 {
634     vn_decode_uint64_t(dec, val);
635 }
636 
637 static inline size_t
vn_sizeof_VkDeviceAddress_array(const VkDeviceAddress * val,uint32_t count)638 vn_sizeof_VkDeviceAddress_array(const VkDeviceAddress *val, uint32_t count)
639 {
640     return vn_sizeof_uint64_t_array(val, count);
641 }
642 
643 static inline void
vn_encode_VkDeviceAddress_array(struct vn_cs_encoder * enc,const VkDeviceAddress * val,uint32_t count)644 vn_encode_VkDeviceAddress_array(struct vn_cs_encoder *enc, const VkDeviceAddress *val, uint32_t count)
645 {
646     vn_encode_uint64_t_array(enc, val, count);
647 }
648 
649 static inline void
vn_decode_VkDeviceAddress_array(struct vn_cs_decoder * dec,VkDeviceAddress * val,uint32_t count)650 vn_decode_VkDeviceAddress_array(struct vn_cs_decoder *dec, VkDeviceAddress *val, uint32_t count)
651 {
652     vn_decode_uint64_t_array(dec, val, count);
653 }
654 
655 /* enum VkFramebufferCreateFlagBits */
656 
657 static inline size_t
vn_sizeof_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits * val)658 vn_sizeof_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits *val)
659 {
660     assert(sizeof(*val) == sizeof(int32_t));
661     return vn_sizeof_int32_t((const int32_t *)val);
662 }
663 
664 static inline void
vn_encode_VkFramebufferCreateFlagBits(struct vn_cs_encoder * enc,const VkFramebufferCreateFlagBits * val)665 vn_encode_VkFramebufferCreateFlagBits(struct vn_cs_encoder *enc, const VkFramebufferCreateFlagBits *val)
666 {
667     vn_encode_int32_t(enc, (const int32_t *)val);
668 }
669 
670 static inline void
vn_decode_VkFramebufferCreateFlagBits(struct vn_cs_decoder * dec,VkFramebufferCreateFlagBits * val)671 vn_decode_VkFramebufferCreateFlagBits(struct vn_cs_decoder *dec, VkFramebufferCreateFlagBits *val)
672 {
673     vn_decode_int32_t(dec, (int32_t *)val);
674 }
675 
676 /* enum VkRenderPassCreateFlagBits */
677 
678 static inline size_t
vn_sizeof_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits * val)679 vn_sizeof_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits *val)
680 {
681     assert(sizeof(*val) == sizeof(int32_t));
682     return vn_sizeof_int32_t((const int32_t *)val);
683 }
684 
685 static inline void
vn_encode_VkRenderPassCreateFlagBits(struct vn_cs_encoder * enc,const VkRenderPassCreateFlagBits * val)686 vn_encode_VkRenderPassCreateFlagBits(struct vn_cs_encoder *enc, const VkRenderPassCreateFlagBits *val)
687 {
688     vn_encode_int32_t(enc, (const int32_t *)val);
689 }
690 
691 static inline void
vn_decode_VkRenderPassCreateFlagBits(struct vn_cs_decoder * dec,VkRenderPassCreateFlagBits * val)692 vn_decode_VkRenderPassCreateFlagBits(struct vn_cs_decoder *dec, VkRenderPassCreateFlagBits *val)
693 {
694     vn_decode_int32_t(dec, (int32_t *)val);
695 }
696 
697 /* enum VkSamplerCreateFlagBits */
698 
699 static inline size_t
vn_sizeof_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits * val)700 vn_sizeof_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits *val)
701 {
702     assert(sizeof(*val) == sizeof(int32_t));
703     return vn_sizeof_int32_t((const int32_t *)val);
704 }
705 
706 static inline void
vn_encode_VkSamplerCreateFlagBits(struct vn_cs_encoder * enc,const VkSamplerCreateFlagBits * val)707 vn_encode_VkSamplerCreateFlagBits(struct vn_cs_encoder *enc, const VkSamplerCreateFlagBits *val)
708 {
709     vn_encode_int32_t(enc, (const int32_t *)val);
710 }
711 
712 static inline void
vn_decode_VkSamplerCreateFlagBits(struct vn_cs_decoder * dec,VkSamplerCreateFlagBits * val)713 vn_decode_VkSamplerCreateFlagBits(struct vn_cs_decoder *dec, VkSamplerCreateFlagBits *val)
714 {
715     vn_decode_int32_t(dec, (int32_t *)val);
716 }
717 
718 /* enum VkPipelineCacheCreateFlagBits */
719 
720 static inline size_t
vn_sizeof_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits * val)721 vn_sizeof_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits *val)
722 {
723     assert(sizeof(*val) == sizeof(int32_t));
724     return vn_sizeof_int32_t((const int32_t *)val);
725 }
726 
727 static inline void
vn_encode_VkPipelineCacheCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineCacheCreateFlagBits * val)728 vn_encode_VkPipelineCacheCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCacheCreateFlagBits *val)
729 {
730     vn_encode_int32_t(enc, (const int32_t *)val);
731 }
732 
733 static inline void
vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineCacheCreateFlagBits * val)734 vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCacheCreateFlagBits *val)
735 {
736     vn_decode_int32_t(dec, (int32_t *)val);
737 }
738 
739 /* enum VkPipelineDepthStencilStateCreateFlagBits */
740 
741 static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateFlagBits(const VkPipelineDepthStencilStateCreateFlagBits * val)742 vn_sizeof_VkPipelineDepthStencilStateCreateFlagBits(const VkPipelineDepthStencilStateCreateFlagBits *val)
743 {
744     assert(sizeof(*val) == sizeof(int32_t));
745     return vn_sizeof_int32_t((const int32_t *)val);
746 }
747 
748 static inline void
vn_encode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineDepthStencilStateCreateFlagBits * val)749 vn_encode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateFlagBits *val)
750 {
751     vn_encode_int32_t(enc, (const int32_t *)val);
752 }
753 
754 static inline void
vn_decode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineDepthStencilStateCreateFlagBits * val)755 vn_decode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateFlagBits *val)
756 {
757     vn_decode_int32_t(dec, (int32_t *)val);
758 }
759 
760 /* enum VkPipelineColorBlendStateCreateFlagBits */
761 
762 static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateFlagBits(const VkPipelineColorBlendStateCreateFlagBits * val)763 vn_sizeof_VkPipelineColorBlendStateCreateFlagBits(const VkPipelineColorBlendStateCreateFlagBits *val)
764 {
765     assert(sizeof(*val) == sizeof(int32_t));
766     return vn_sizeof_int32_t((const int32_t *)val);
767 }
768 
769 static inline void
vn_encode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineColorBlendStateCreateFlagBits * val)770 vn_encode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateFlagBits *val)
771 {
772     vn_encode_int32_t(enc, (const int32_t *)val);
773 }
774 
775 static inline void
vn_decode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineColorBlendStateCreateFlagBits * val)776 vn_decode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateFlagBits *val)
777 {
778     vn_decode_int32_t(dec, (int32_t *)val);
779 }
780 
781 /* enum VkPipelineShaderStageCreateFlagBits */
782 
783 static inline size_t
vn_sizeof_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits * val)784 vn_sizeof_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits *val)
785 {
786     assert(sizeof(*val) == sizeof(int32_t));
787     return vn_sizeof_int32_t((const int32_t *)val);
788 }
789 
790 static inline void
vn_encode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineShaderStageCreateFlagBits * val)791 vn_encode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateFlagBits *val)
792 {
793     vn_encode_int32_t(enc, (const int32_t *)val);
794 }
795 
796 static inline void
vn_decode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineShaderStageCreateFlagBits * val)797 vn_decode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateFlagBits *val)
798 {
799     vn_decode_int32_t(dec, (int32_t *)val);
800 }
801 
802 /* enum VkDescriptorSetLayoutCreateFlagBits */
803 
804 static inline size_t
vn_sizeof_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits * val)805 vn_sizeof_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits *val)
806 {
807     assert(sizeof(*val) == sizeof(int32_t));
808     return vn_sizeof_int32_t((const int32_t *)val);
809 }
810 
811 static inline void
vn_encode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_encoder * enc,const VkDescriptorSetLayoutCreateFlagBits * val)812 vn_encode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateFlagBits *val)
813 {
814     vn_encode_int32_t(enc, (const int32_t *)val);
815 }
816 
817 static inline void
vn_decode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_decoder * dec,VkDescriptorSetLayoutCreateFlagBits * val)818 vn_decode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorSetLayoutCreateFlagBits *val)
819 {
820     vn_decode_int32_t(dec, (int32_t *)val);
821 }
822 
823 /* enum VkDeviceQueueCreateFlagBits */
824 
825 static inline size_t
vn_sizeof_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits * val)826 vn_sizeof_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits *val)
827 {
828     assert(sizeof(*val) == sizeof(int32_t));
829     return vn_sizeof_int32_t((const int32_t *)val);
830 }
831 
832 static inline void
vn_encode_VkDeviceQueueCreateFlagBits(struct vn_cs_encoder * enc,const VkDeviceQueueCreateFlagBits * val)833 vn_encode_VkDeviceQueueCreateFlagBits(struct vn_cs_encoder *enc, const VkDeviceQueueCreateFlagBits *val)
834 {
835     vn_encode_int32_t(enc, (const int32_t *)val);
836 }
837 
838 static inline void
vn_decode_VkDeviceQueueCreateFlagBits(struct vn_cs_decoder * dec,VkDeviceQueueCreateFlagBits * val)839 vn_decode_VkDeviceQueueCreateFlagBits(struct vn_cs_decoder *dec, VkDeviceQueueCreateFlagBits *val)
840 {
841     vn_decode_int32_t(dec, (int32_t *)val);
842 }
843 
844 /* enum VkQueueFlagBits */
845 
846 static inline size_t
vn_sizeof_VkQueueFlagBits(const VkQueueFlagBits * val)847 vn_sizeof_VkQueueFlagBits(const VkQueueFlagBits *val)
848 {
849     assert(sizeof(*val) == sizeof(int32_t));
850     return vn_sizeof_int32_t((const int32_t *)val);
851 }
852 
853 static inline void
vn_encode_VkQueueFlagBits(struct vn_cs_encoder * enc,const VkQueueFlagBits * val)854 vn_encode_VkQueueFlagBits(struct vn_cs_encoder *enc, const VkQueueFlagBits *val)
855 {
856     vn_encode_int32_t(enc, (const int32_t *)val);
857 }
858 
859 static inline void
vn_decode_VkQueueFlagBits(struct vn_cs_decoder * dec,VkQueueFlagBits * val)860 vn_decode_VkQueueFlagBits(struct vn_cs_decoder *dec, VkQueueFlagBits *val)
861 {
862     vn_decode_int32_t(dec, (int32_t *)val);
863 }
864 
865 /* enum VkMemoryPropertyFlagBits */
866 
867 static inline size_t
vn_sizeof_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits * val)868 vn_sizeof_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits *val)
869 {
870     assert(sizeof(*val) == sizeof(int32_t));
871     return vn_sizeof_int32_t((const int32_t *)val);
872 }
873 
874 static inline void
vn_encode_VkMemoryPropertyFlagBits(struct vn_cs_encoder * enc,const VkMemoryPropertyFlagBits * val)875 vn_encode_VkMemoryPropertyFlagBits(struct vn_cs_encoder *enc, const VkMemoryPropertyFlagBits *val)
876 {
877     vn_encode_int32_t(enc, (const int32_t *)val);
878 }
879 
880 static inline void
vn_decode_VkMemoryPropertyFlagBits(struct vn_cs_decoder * dec,VkMemoryPropertyFlagBits * val)881 vn_decode_VkMemoryPropertyFlagBits(struct vn_cs_decoder *dec, VkMemoryPropertyFlagBits *val)
882 {
883     vn_decode_int32_t(dec, (int32_t *)val);
884 }
885 
886 /* enum VkMemoryHeapFlagBits */
887 
888 static inline size_t
vn_sizeof_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits * val)889 vn_sizeof_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits *val)
890 {
891     assert(sizeof(*val) == sizeof(int32_t));
892     return vn_sizeof_int32_t((const int32_t *)val);
893 }
894 
895 static inline void
vn_encode_VkMemoryHeapFlagBits(struct vn_cs_encoder * enc,const VkMemoryHeapFlagBits * val)896 vn_encode_VkMemoryHeapFlagBits(struct vn_cs_encoder *enc, const VkMemoryHeapFlagBits *val)
897 {
898     vn_encode_int32_t(enc, (const int32_t *)val);
899 }
900 
901 static inline void
vn_decode_VkMemoryHeapFlagBits(struct vn_cs_decoder * dec,VkMemoryHeapFlagBits * val)902 vn_decode_VkMemoryHeapFlagBits(struct vn_cs_decoder *dec, VkMemoryHeapFlagBits *val)
903 {
904     vn_decode_int32_t(dec, (int32_t *)val);
905 }
906 
907 /* enum VkAccessFlagBits */
908 
909 static inline size_t
vn_sizeof_VkAccessFlagBits(const VkAccessFlagBits * val)910 vn_sizeof_VkAccessFlagBits(const VkAccessFlagBits *val)
911 {
912     assert(sizeof(*val) == sizeof(int32_t));
913     return vn_sizeof_int32_t((const int32_t *)val);
914 }
915 
916 static inline void
vn_encode_VkAccessFlagBits(struct vn_cs_encoder * enc,const VkAccessFlagBits * val)917 vn_encode_VkAccessFlagBits(struct vn_cs_encoder *enc, const VkAccessFlagBits *val)
918 {
919     vn_encode_int32_t(enc, (const int32_t *)val);
920 }
921 
922 static inline void
vn_decode_VkAccessFlagBits(struct vn_cs_decoder * dec,VkAccessFlagBits * val)923 vn_decode_VkAccessFlagBits(struct vn_cs_decoder *dec, VkAccessFlagBits *val)
924 {
925     vn_decode_int32_t(dec, (int32_t *)val);
926 }
927 
928 /* enum VkBufferUsageFlagBits */
929 
930 static inline size_t
vn_sizeof_VkBufferUsageFlagBits(const VkBufferUsageFlagBits * val)931 vn_sizeof_VkBufferUsageFlagBits(const VkBufferUsageFlagBits *val)
932 {
933     assert(sizeof(*val) == sizeof(int32_t));
934     return vn_sizeof_int32_t((const int32_t *)val);
935 }
936 
937 static inline void
vn_encode_VkBufferUsageFlagBits(struct vn_cs_encoder * enc,const VkBufferUsageFlagBits * val)938 vn_encode_VkBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkBufferUsageFlagBits *val)
939 {
940     vn_encode_int32_t(enc, (const int32_t *)val);
941 }
942 
943 static inline void
vn_decode_VkBufferUsageFlagBits(struct vn_cs_decoder * dec,VkBufferUsageFlagBits * val)944 vn_decode_VkBufferUsageFlagBits(struct vn_cs_decoder *dec, VkBufferUsageFlagBits *val)
945 {
946     vn_decode_int32_t(dec, (int32_t *)val);
947 }
948 
949 /* enum VkBufferCreateFlagBits */
950 
951 static inline size_t
vn_sizeof_VkBufferCreateFlagBits(const VkBufferCreateFlagBits * val)952 vn_sizeof_VkBufferCreateFlagBits(const VkBufferCreateFlagBits *val)
953 {
954     assert(sizeof(*val) == sizeof(int32_t));
955     return vn_sizeof_int32_t((const int32_t *)val);
956 }
957 
958 static inline void
vn_encode_VkBufferCreateFlagBits(struct vn_cs_encoder * enc,const VkBufferCreateFlagBits * val)959 vn_encode_VkBufferCreateFlagBits(struct vn_cs_encoder *enc, const VkBufferCreateFlagBits *val)
960 {
961     vn_encode_int32_t(enc, (const int32_t *)val);
962 }
963 
964 static inline void
vn_decode_VkBufferCreateFlagBits(struct vn_cs_decoder * dec,VkBufferCreateFlagBits * val)965 vn_decode_VkBufferCreateFlagBits(struct vn_cs_decoder *dec, VkBufferCreateFlagBits *val)
966 {
967     vn_decode_int32_t(dec, (int32_t *)val);
968 }
969 
970 /* enum VkShaderStageFlagBits */
971 
972 static inline size_t
vn_sizeof_VkShaderStageFlagBits(const VkShaderStageFlagBits * val)973 vn_sizeof_VkShaderStageFlagBits(const VkShaderStageFlagBits *val)
974 {
975     assert(sizeof(*val) == sizeof(int32_t));
976     return vn_sizeof_int32_t((const int32_t *)val);
977 }
978 
979 static inline void
vn_encode_VkShaderStageFlagBits(struct vn_cs_encoder * enc,const VkShaderStageFlagBits * val)980 vn_encode_VkShaderStageFlagBits(struct vn_cs_encoder *enc, const VkShaderStageFlagBits *val)
981 {
982     vn_encode_int32_t(enc, (const int32_t *)val);
983 }
984 
985 static inline void
vn_decode_VkShaderStageFlagBits(struct vn_cs_decoder * dec,VkShaderStageFlagBits * val)986 vn_decode_VkShaderStageFlagBits(struct vn_cs_decoder *dec, VkShaderStageFlagBits *val)
987 {
988     vn_decode_int32_t(dec, (int32_t *)val);
989 }
990 
991 /* enum VkImageUsageFlagBits */
992 
993 static inline size_t
vn_sizeof_VkImageUsageFlagBits(const VkImageUsageFlagBits * val)994 vn_sizeof_VkImageUsageFlagBits(const VkImageUsageFlagBits *val)
995 {
996     assert(sizeof(*val) == sizeof(int32_t));
997     return vn_sizeof_int32_t((const int32_t *)val);
998 }
999 
1000 static inline void
vn_encode_VkImageUsageFlagBits(struct vn_cs_encoder * enc,const VkImageUsageFlagBits * val)1001 vn_encode_VkImageUsageFlagBits(struct vn_cs_encoder *enc, const VkImageUsageFlagBits *val)
1002 {
1003     vn_encode_int32_t(enc, (const int32_t *)val);
1004 }
1005 
1006 static inline void
vn_decode_VkImageUsageFlagBits(struct vn_cs_decoder * dec,VkImageUsageFlagBits * val)1007 vn_decode_VkImageUsageFlagBits(struct vn_cs_decoder *dec, VkImageUsageFlagBits *val)
1008 {
1009     vn_decode_int32_t(dec, (int32_t *)val);
1010 }
1011 
1012 /* enum VkImageCreateFlagBits */
1013 
1014 static inline size_t
vn_sizeof_VkImageCreateFlagBits(const VkImageCreateFlagBits * val)1015 vn_sizeof_VkImageCreateFlagBits(const VkImageCreateFlagBits *val)
1016 {
1017     assert(sizeof(*val) == sizeof(int32_t));
1018     return vn_sizeof_int32_t((const int32_t *)val);
1019 }
1020 
1021 static inline void
vn_encode_VkImageCreateFlagBits(struct vn_cs_encoder * enc,const VkImageCreateFlagBits * val)1022 vn_encode_VkImageCreateFlagBits(struct vn_cs_encoder *enc, const VkImageCreateFlagBits *val)
1023 {
1024     vn_encode_int32_t(enc, (const int32_t *)val);
1025 }
1026 
1027 static inline void
vn_decode_VkImageCreateFlagBits(struct vn_cs_decoder * dec,VkImageCreateFlagBits * val)1028 vn_decode_VkImageCreateFlagBits(struct vn_cs_decoder *dec, VkImageCreateFlagBits *val)
1029 {
1030     vn_decode_int32_t(dec, (int32_t *)val);
1031 }
1032 
1033 /* enum VkImageViewCreateFlagBits */
1034 
1035 static inline size_t
vn_sizeof_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits * val)1036 vn_sizeof_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits *val)
1037 {
1038     assert(sizeof(*val) == sizeof(int32_t));
1039     return vn_sizeof_int32_t((const int32_t *)val);
1040 }
1041 
1042 static inline void
vn_encode_VkImageViewCreateFlagBits(struct vn_cs_encoder * enc,const VkImageViewCreateFlagBits * val)1043 vn_encode_VkImageViewCreateFlagBits(struct vn_cs_encoder *enc, const VkImageViewCreateFlagBits *val)
1044 {
1045     vn_encode_int32_t(enc, (const int32_t *)val);
1046 }
1047 
1048 static inline void
vn_decode_VkImageViewCreateFlagBits(struct vn_cs_decoder * dec,VkImageViewCreateFlagBits * val)1049 vn_decode_VkImageViewCreateFlagBits(struct vn_cs_decoder *dec, VkImageViewCreateFlagBits *val)
1050 {
1051     vn_decode_int32_t(dec, (int32_t *)val);
1052 }
1053 
1054 /* enum VkPipelineCreateFlagBits */
1055 
1056 static inline size_t
vn_sizeof_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits * val)1057 vn_sizeof_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits *val)
1058 {
1059     assert(sizeof(*val) == sizeof(int32_t));
1060     return vn_sizeof_int32_t((const int32_t *)val);
1061 }
1062 
1063 static inline void
vn_encode_VkPipelineCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineCreateFlagBits * val)1064 vn_encode_VkPipelineCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreateFlagBits *val)
1065 {
1066     vn_encode_int32_t(enc, (const int32_t *)val);
1067 }
1068 
1069 static inline void
vn_decode_VkPipelineCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineCreateFlagBits * val)1070 vn_decode_VkPipelineCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCreateFlagBits *val)
1071 {
1072     vn_decode_int32_t(dec, (int32_t *)val);
1073 }
1074 
1075 /* enum VkColorComponentFlagBits */
1076 
1077 static inline size_t
vn_sizeof_VkColorComponentFlagBits(const VkColorComponentFlagBits * val)1078 vn_sizeof_VkColorComponentFlagBits(const VkColorComponentFlagBits *val)
1079 {
1080     assert(sizeof(*val) == sizeof(int32_t));
1081     return vn_sizeof_int32_t((const int32_t *)val);
1082 }
1083 
1084 static inline void
vn_encode_VkColorComponentFlagBits(struct vn_cs_encoder * enc,const VkColorComponentFlagBits * val)1085 vn_encode_VkColorComponentFlagBits(struct vn_cs_encoder *enc, const VkColorComponentFlagBits *val)
1086 {
1087     vn_encode_int32_t(enc, (const int32_t *)val);
1088 }
1089 
1090 static inline void
vn_decode_VkColorComponentFlagBits(struct vn_cs_decoder * dec,VkColorComponentFlagBits * val)1091 vn_decode_VkColorComponentFlagBits(struct vn_cs_decoder *dec, VkColorComponentFlagBits *val)
1092 {
1093     vn_decode_int32_t(dec, (int32_t *)val);
1094 }
1095 
1096 /* enum VkFenceCreateFlagBits */
1097 
1098 static inline size_t
vn_sizeof_VkFenceCreateFlagBits(const VkFenceCreateFlagBits * val)1099 vn_sizeof_VkFenceCreateFlagBits(const VkFenceCreateFlagBits *val)
1100 {
1101     assert(sizeof(*val) == sizeof(int32_t));
1102     return vn_sizeof_int32_t((const int32_t *)val);
1103 }
1104 
1105 static inline void
vn_encode_VkFenceCreateFlagBits(struct vn_cs_encoder * enc,const VkFenceCreateFlagBits * val)1106 vn_encode_VkFenceCreateFlagBits(struct vn_cs_encoder *enc, const VkFenceCreateFlagBits *val)
1107 {
1108     vn_encode_int32_t(enc, (const int32_t *)val);
1109 }
1110 
1111 static inline void
vn_decode_VkFenceCreateFlagBits(struct vn_cs_decoder * dec,VkFenceCreateFlagBits * val)1112 vn_decode_VkFenceCreateFlagBits(struct vn_cs_decoder *dec, VkFenceCreateFlagBits *val)
1113 {
1114     vn_decode_int32_t(dec, (int32_t *)val);
1115 }
1116 
1117 /* enum VkFormatFeatureFlagBits */
1118 
1119 static inline size_t
vn_sizeof_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits * val)1120 vn_sizeof_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits *val)
1121 {
1122     assert(sizeof(*val) == sizeof(int32_t));
1123     return vn_sizeof_int32_t((const int32_t *)val);
1124 }
1125 
1126 static inline void
vn_encode_VkFormatFeatureFlagBits(struct vn_cs_encoder * enc,const VkFormatFeatureFlagBits * val)1127 vn_encode_VkFormatFeatureFlagBits(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits *val)
1128 {
1129     vn_encode_int32_t(enc, (const int32_t *)val);
1130 }
1131 
1132 static inline void
vn_decode_VkFormatFeatureFlagBits(struct vn_cs_decoder * dec,VkFormatFeatureFlagBits * val)1133 vn_decode_VkFormatFeatureFlagBits(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits *val)
1134 {
1135     vn_decode_int32_t(dec, (int32_t *)val);
1136 }
1137 
1138 /* enum VkQueryControlFlagBits */
1139 
1140 static inline size_t
vn_sizeof_VkQueryControlFlagBits(const VkQueryControlFlagBits * val)1141 vn_sizeof_VkQueryControlFlagBits(const VkQueryControlFlagBits *val)
1142 {
1143     assert(sizeof(*val) == sizeof(int32_t));
1144     return vn_sizeof_int32_t((const int32_t *)val);
1145 }
1146 
1147 static inline void
vn_encode_VkQueryControlFlagBits(struct vn_cs_encoder * enc,const VkQueryControlFlagBits * val)1148 vn_encode_VkQueryControlFlagBits(struct vn_cs_encoder *enc, const VkQueryControlFlagBits *val)
1149 {
1150     vn_encode_int32_t(enc, (const int32_t *)val);
1151 }
1152 
1153 static inline void
vn_decode_VkQueryControlFlagBits(struct vn_cs_decoder * dec,VkQueryControlFlagBits * val)1154 vn_decode_VkQueryControlFlagBits(struct vn_cs_decoder *dec, VkQueryControlFlagBits *val)
1155 {
1156     vn_decode_int32_t(dec, (int32_t *)val);
1157 }
1158 
1159 /* enum VkQueryResultFlagBits */
1160 
1161 static inline size_t
vn_sizeof_VkQueryResultFlagBits(const VkQueryResultFlagBits * val)1162 vn_sizeof_VkQueryResultFlagBits(const VkQueryResultFlagBits *val)
1163 {
1164     assert(sizeof(*val) == sizeof(int32_t));
1165     return vn_sizeof_int32_t((const int32_t *)val);
1166 }
1167 
1168 static inline void
vn_encode_VkQueryResultFlagBits(struct vn_cs_encoder * enc,const VkQueryResultFlagBits * val)1169 vn_encode_VkQueryResultFlagBits(struct vn_cs_encoder *enc, const VkQueryResultFlagBits *val)
1170 {
1171     vn_encode_int32_t(enc, (const int32_t *)val);
1172 }
1173 
1174 static inline void
vn_decode_VkQueryResultFlagBits(struct vn_cs_decoder * dec,VkQueryResultFlagBits * val)1175 vn_decode_VkQueryResultFlagBits(struct vn_cs_decoder *dec, VkQueryResultFlagBits *val)
1176 {
1177     vn_decode_int32_t(dec, (int32_t *)val);
1178 }
1179 
1180 /* enum VkEventCreateFlagBits */
1181 
1182 static inline size_t
vn_sizeof_VkEventCreateFlagBits(const VkEventCreateFlagBits * val)1183 vn_sizeof_VkEventCreateFlagBits(const VkEventCreateFlagBits *val)
1184 {
1185     assert(sizeof(*val) == sizeof(int32_t));
1186     return vn_sizeof_int32_t((const int32_t *)val);
1187 }
1188 
1189 static inline void
vn_encode_VkEventCreateFlagBits(struct vn_cs_encoder * enc,const VkEventCreateFlagBits * val)1190 vn_encode_VkEventCreateFlagBits(struct vn_cs_encoder *enc, const VkEventCreateFlagBits *val)
1191 {
1192     vn_encode_int32_t(enc, (const int32_t *)val);
1193 }
1194 
1195 static inline void
vn_decode_VkEventCreateFlagBits(struct vn_cs_decoder * dec,VkEventCreateFlagBits * val)1196 vn_decode_VkEventCreateFlagBits(struct vn_cs_decoder *dec, VkEventCreateFlagBits *val)
1197 {
1198     vn_decode_int32_t(dec, (int32_t *)val);
1199 }
1200 
1201 /* enum VkCommandPoolCreateFlagBits */
1202 
1203 static inline size_t
vn_sizeof_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits * val)1204 vn_sizeof_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits *val)
1205 {
1206     assert(sizeof(*val) == sizeof(int32_t));
1207     return vn_sizeof_int32_t((const int32_t *)val);
1208 }
1209 
1210 static inline void
vn_encode_VkCommandPoolCreateFlagBits(struct vn_cs_encoder * enc,const VkCommandPoolCreateFlagBits * val)1211 vn_encode_VkCommandPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolCreateFlagBits *val)
1212 {
1213     vn_encode_int32_t(enc, (const int32_t *)val);
1214 }
1215 
1216 static inline void
vn_decode_VkCommandPoolCreateFlagBits(struct vn_cs_decoder * dec,VkCommandPoolCreateFlagBits * val)1217 vn_decode_VkCommandPoolCreateFlagBits(struct vn_cs_decoder *dec, VkCommandPoolCreateFlagBits *val)
1218 {
1219     vn_decode_int32_t(dec, (int32_t *)val);
1220 }
1221 
1222 /* enum VkCommandPoolResetFlagBits */
1223 
1224 static inline size_t
vn_sizeof_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits * val)1225 vn_sizeof_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits *val)
1226 {
1227     assert(sizeof(*val) == sizeof(int32_t));
1228     return vn_sizeof_int32_t((const int32_t *)val);
1229 }
1230 
1231 static inline void
vn_encode_VkCommandPoolResetFlagBits(struct vn_cs_encoder * enc,const VkCommandPoolResetFlagBits * val)1232 vn_encode_VkCommandPoolResetFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolResetFlagBits *val)
1233 {
1234     vn_encode_int32_t(enc, (const int32_t *)val);
1235 }
1236 
1237 static inline void
vn_decode_VkCommandPoolResetFlagBits(struct vn_cs_decoder * dec,VkCommandPoolResetFlagBits * val)1238 vn_decode_VkCommandPoolResetFlagBits(struct vn_cs_decoder *dec, VkCommandPoolResetFlagBits *val)
1239 {
1240     vn_decode_int32_t(dec, (int32_t *)val);
1241 }
1242 
1243 /* enum VkCommandBufferResetFlagBits */
1244 
1245 static inline size_t
vn_sizeof_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits * val)1246 vn_sizeof_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits *val)
1247 {
1248     assert(sizeof(*val) == sizeof(int32_t));
1249     return vn_sizeof_int32_t((const int32_t *)val);
1250 }
1251 
1252 static inline void
vn_encode_VkCommandBufferResetFlagBits(struct vn_cs_encoder * enc,const VkCommandBufferResetFlagBits * val)1253 vn_encode_VkCommandBufferResetFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferResetFlagBits *val)
1254 {
1255     vn_encode_int32_t(enc, (const int32_t *)val);
1256 }
1257 
1258 static inline void
vn_decode_VkCommandBufferResetFlagBits(struct vn_cs_decoder * dec,VkCommandBufferResetFlagBits * val)1259 vn_decode_VkCommandBufferResetFlagBits(struct vn_cs_decoder *dec, VkCommandBufferResetFlagBits *val)
1260 {
1261     vn_decode_int32_t(dec, (int32_t *)val);
1262 }
1263 
1264 /* enum VkCommandBufferUsageFlagBits */
1265 
1266 static inline size_t
vn_sizeof_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits * val)1267 vn_sizeof_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits *val)
1268 {
1269     assert(sizeof(*val) == sizeof(int32_t));
1270     return vn_sizeof_int32_t((const int32_t *)val);
1271 }
1272 
1273 static inline void
vn_encode_VkCommandBufferUsageFlagBits(struct vn_cs_encoder * enc,const VkCommandBufferUsageFlagBits * val)1274 vn_encode_VkCommandBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferUsageFlagBits *val)
1275 {
1276     vn_encode_int32_t(enc, (const int32_t *)val);
1277 }
1278 
1279 static inline void
vn_decode_VkCommandBufferUsageFlagBits(struct vn_cs_decoder * dec,VkCommandBufferUsageFlagBits * val)1280 vn_decode_VkCommandBufferUsageFlagBits(struct vn_cs_decoder *dec, VkCommandBufferUsageFlagBits *val)
1281 {
1282     vn_decode_int32_t(dec, (int32_t *)val);
1283 }
1284 
1285 /* enum VkQueryPipelineStatisticFlagBits */
1286 
1287 static inline size_t
vn_sizeof_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits * val)1288 vn_sizeof_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits *val)
1289 {
1290     assert(sizeof(*val) == sizeof(int32_t));
1291     return vn_sizeof_int32_t((const int32_t *)val);
1292 }
1293 
1294 static inline void
vn_encode_VkQueryPipelineStatisticFlagBits(struct vn_cs_encoder * enc,const VkQueryPipelineStatisticFlagBits * val)1295 vn_encode_VkQueryPipelineStatisticFlagBits(struct vn_cs_encoder *enc, const VkQueryPipelineStatisticFlagBits *val)
1296 {
1297     vn_encode_int32_t(enc, (const int32_t *)val);
1298 }
1299 
1300 static inline void
vn_decode_VkQueryPipelineStatisticFlagBits(struct vn_cs_decoder * dec,VkQueryPipelineStatisticFlagBits * val)1301 vn_decode_VkQueryPipelineStatisticFlagBits(struct vn_cs_decoder *dec, VkQueryPipelineStatisticFlagBits *val)
1302 {
1303     vn_decode_int32_t(dec, (int32_t *)val);
1304 }
1305 
1306 /* enum VkImageAspectFlagBits */
1307 
1308 static inline size_t
vn_sizeof_VkImageAspectFlagBits(const VkImageAspectFlagBits * val)1309 vn_sizeof_VkImageAspectFlagBits(const VkImageAspectFlagBits *val)
1310 {
1311     assert(sizeof(*val) == sizeof(int32_t));
1312     return vn_sizeof_int32_t((const int32_t *)val);
1313 }
1314 
1315 static inline void
vn_encode_VkImageAspectFlagBits(struct vn_cs_encoder * enc,const VkImageAspectFlagBits * val)1316 vn_encode_VkImageAspectFlagBits(struct vn_cs_encoder *enc, const VkImageAspectFlagBits *val)
1317 {
1318     vn_encode_int32_t(enc, (const int32_t *)val);
1319 }
1320 
1321 static inline void
vn_decode_VkImageAspectFlagBits(struct vn_cs_decoder * dec,VkImageAspectFlagBits * val)1322 vn_decode_VkImageAspectFlagBits(struct vn_cs_decoder *dec, VkImageAspectFlagBits *val)
1323 {
1324     vn_decode_int32_t(dec, (int32_t *)val);
1325 }
1326 
1327 /* enum VkSparseMemoryBindFlagBits */
1328 
1329 static inline size_t
vn_sizeof_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits * val)1330 vn_sizeof_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits *val)
1331 {
1332     assert(sizeof(*val) == sizeof(int32_t));
1333     return vn_sizeof_int32_t((const int32_t *)val);
1334 }
1335 
1336 static inline void
vn_encode_VkSparseMemoryBindFlagBits(struct vn_cs_encoder * enc,const VkSparseMemoryBindFlagBits * val)1337 vn_encode_VkSparseMemoryBindFlagBits(struct vn_cs_encoder *enc, const VkSparseMemoryBindFlagBits *val)
1338 {
1339     vn_encode_int32_t(enc, (const int32_t *)val);
1340 }
1341 
1342 static inline void
vn_decode_VkSparseMemoryBindFlagBits(struct vn_cs_decoder * dec,VkSparseMemoryBindFlagBits * val)1343 vn_decode_VkSparseMemoryBindFlagBits(struct vn_cs_decoder *dec, VkSparseMemoryBindFlagBits *val)
1344 {
1345     vn_decode_int32_t(dec, (int32_t *)val);
1346 }
1347 
1348 /* enum VkSparseImageFormatFlagBits */
1349 
1350 static inline size_t
vn_sizeof_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits * val)1351 vn_sizeof_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits *val)
1352 {
1353     assert(sizeof(*val) == sizeof(int32_t));
1354     return vn_sizeof_int32_t((const int32_t *)val);
1355 }
1356 
1357 static inline void
vn_encode_VkSparseImageFormatFlagBits(struct vn_cs_encoder * enc,const VkSparseImageFormatFlagBits * val)1358 vn_encode_VkSparseImageFormatFlagBits(struct vn_cs_encoder *enc, const VkSparseImageFormatFlagBits *val)
1359 {
1360     vn_encode_int32_t(enc, (const int32_t *)val);
1361 }
1362 
1363 static inline void
vn_decode_VkSparseImageFormatFlagBits(struct vn_cs_decoder * dec,VkSparseImageFormatFlagBits * val)1364 vn_decode_VkSparseImageFormatFlagBits(struct vn_cs_decoder *dec, VkSparseImageFormatFlagBits *val)
1365 {
1366     vn_decode_int32_t(dec, (int32_t *)val);
1367 }
1368 
1369 /* enum VkSubpassDescriptionFlagBits */
1370 
1371 static inline size_t
vn_sizeof_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits * val)1372 vn_sizeof_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits *val)
1373 {
1374     assert(sizeof(*val) == sizeof(int32_t));
1375     return vn_sizeof_int32_t((const int32_t *)val);
1376 }
1377 
1378 static inline void
vn_encode_VkSubpassDescriptionFlagBits(struct vn_cs_encoder * enc,const VkSubpassDescriptionFlagBits * val)1379 vn_encode_VkSubpassDescriptionFlagBits(struct vn_cs_encoder *enc, const VkSubpassDescriptionFlagBits *val)
1380 {
1381     vn_encode_int32_t(enc, (const int32_t *)val);
1382 }
1383 
1384 static inline void
vn_decode_VkSubpassDescriptionFlagBits(struct vn_cs_decoder * dec,VkSubpassDescriptionFlagBits * val)1385 vn_decode_VkSubpassDescriptionFlagBits(struct vn_cs_decoder *dec, VkSubpassDescriptionFlagBits *val)
1386 {
1387     vn_decode_int32_t(dec, (int32_t *)val);
1388 }
1389 
1390 /* enum VkPipelineStageFlagBits */
1391 
1392 static inline size_t
vn_sizeof_VkPipelineStageFlagBits(const VkPipelineStageFlagBits * val)1393 vn_sizeof_VkPipelineStageFlagBits(const VkPipelineStageFlagBits *val)
1394 {
1395     assert(sizeof(*val) == sizeof(int32_t));
1396     return vn_sizeof_int32_t((const int32_t *)val);
1397 }
1398 
1399 static inline void
vn_encode_VkPipelineStageFlagBits(struct vn_cs_encoder * enc,const VkPipelineStageFlagBits * val)1400 vn_encode_VkPipelineStageFlagBits(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits *val)
1401 {
1402     vn_encode_int32_t(enc, (const int32_t *)val);
1403 }
1404 
1405 static inline void
vn_decode_VkPipelineStageFlagBits(struct vn_cs_decoder * dec,VkPipelineStageFlagBits * val)1406 vn_decode_VkPipelineStageFlagBits(struct vn_cs_decoder *dec, VkPipelineStageFlagBits *val)
1407 {
1408     vn_decode_int32_t(dec, (int32_t *)val);
1409 }
1410 
1411 /* enum VkSampleCountFlagBits */
1412 
1413 static inline size_t
vn_sizeof_VkSampleCountFlagBits(const VkSampleCountFlagBits * val)1414 vn_sizeof_VkSampleCountFlagBits(const VkSampleCountFlagBits *val)
1415 {
1416     assert(sizeof(*val) == sizeof(int32_t));
1417     return vn_sizeof_int32_t((const int32_t *)val);
1418 }
1419 
1420 static inline void
vn_encode_VkSampleCountFlagBits(struct vn_cs_encoder * enc,const VkSampleCountFlagBits * val)1421 vn_encode_VkSampleCountFlagBits(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val)
1422 {
1423     vn_encode_int32_t(enc, (const int32_t *)val);
1424 }
1425 
1426 static inline void
vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder * dec,VkSampleCountFlagBits * val)1427 vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val)
1428 {
1429     vn_decode_int32_t(dec, (int32_t *)val);
1430 }
1431 
1432 static inline size_t
vn_sizeof_VkSampleCountFlagBits_array(const VkSampleCountFlagBits * val,uint32_t count)1433 vn_sizeof_VkSampleCountFlagBits_array(const VkSampleCountFlagBits *val, uint32_t count)
1434 {
1435     return vn_sizeof_int32_t_array((const int32_t *)val, count);
1436 }
1437 
1438 static inline void
vn_encode_VkSampleCountFlagBits_array(struct vn_cs_encoder * enc,const VkSampleCountFlagBits * val,uint32_t count)1439 vn_encode_VkSampleCountFlagBits_array(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val, uint32_t count)
1440 {
1441     vn_encode_int32_t_array(enc, (const int32_t *)val, count);
1442 }
1443 
1444 static inline void
vn_decode_VkSampleCountFlagBits_array(struct vn_cs_decoder * dec,VkSampleCountFlagBits * val,uint32_t count)1445 vn_decode_VkSampleCountFlagBits_array(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val, uint32_t count)
1446 {
1447     vn_decode_int32_t_array(dec, (int32_t *)val, count);
1448 }
1449 
1450 /* enum VkAttachmentDescriptionFlagBits */
1451 
1452 static inline size_t
vn_sizeof_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits * val)1453 vn_sizeof_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits *val)
1454 {
1455     assert(sizeof(*val) == sizeof(int32_t));
1456     return vn_sizeof_int32_t((const int32_t *)val);
1457 }
1458 
1459 static inline void
vn_encode_VkAttachmentDescriptionFlagBits(struct vn_cs_encoder * enc,const VkAttachmentDescriptionFlagBits * val)1460 vn_encode_VkAttachmentDescriptionFlagBits(struct vn_cs_encoder *enc, const VkAttachmentDescriptionFlagBits *val)
1461 {
1462     vn_encode_int32_t(enc, (const int32_t *)val);
1463 }
1464 
1465 static inline void
vn_decode_VkAttachmentDescriptionFlagBits(struct vn_cs_decoder * dec,VkAttachmentDescriptionFlagBits * val)1466 vn_decode_VkAttachmentDescriptionFlagBits(struct vn_cs_decoder *dec, VkAttachmentDescriptionFlagBits *val)
1467 {
1468     vn_decode_int32_t(dec, (int32_t *)val);
1469 }
1470 
1471 /* enum VkStencilFaceFlagBits */
1472 
1473 static inline size_t
vn_sizeof_VkStencilFaceFlagBits(const VkStencilFaceFlagBits * val)1474 vn_sizeof_VkStencilFaceFlagBits(const VkStencilFaceFlagBits *val)
1475 {
1476     assert(sizeof(*val) == sizeof(int32_t));
1477     return vn_sizeof_int32_t((const int32_t *)val);
1478 }
1479 
1480 static inline void
vn_encode_VkStencilFaceFlagBits(struct vn_cs_encoder * enc,const VkStencilFaceFlagBits * val)1481 vn_encode_VkStencilFaceFlagBits(struct vn_cs_encoder *enc, const VkStencilFaceFlagBits *val)
1482 {
1483     vn_encode_int32_t(enc, (const int32_t *)val);
1484 }
1485 
1486 static inline void
vn_decode_VkStencilFaceFlagBits(struct vn_cs_decoder * dec,VkStencilFaceFlagBits * val)1487 vn_decode_VkStencilFaceFlagBits(struct vn_cs_decoder *dec, VkStencilFaceFlagBits *val)
1488 {
1489     vn_decode_int32_t(dec, (int32_t *)val);
1490 }
1491 
1492 /* enum VkCullModeFlagBits */
1493 
1494 static inline size_t
vn_sizeof_VkCullModeFlagBits(const VkCullModeFlagBits * val)1495 vn_sizeof_VkCullModeFlagBits(const VkCullModeFlagBits *val)
1496 {
1497     assert(sizeof(*val) == sizeof(int32_t));
1498     return vn_sizeof_int32_t((const int32_t *)val);
1499 }
1500 
1501 static inline void
vn_encode_VkCullModeFlagBits(struct vn_cs_encoder * enc,const VkCullModeFlagBits * val)1502 vn_encode_VkCullModeFlagBits(struct vn_cs_encoder *enc, const VkCullModeFlagBits *val)
1503 {
1504     vn_encode_int32_t(enc, (const int32_t *)val);
1505 }
1506 
1507 static inline void
vn_decode_VkCullModeFlagBits(struct vn_cs_decoder * dec,VkCullModeFlagBits * val)1508 vn_decode_VkCullModeFlagBits(struct vn_cs_decoder *dec, VkCullModeFlagBits *val)
1509 {
1510     vn_decode_int32_t(dec, (int32_t *)val);
1511 }
1512 
1513 /* enum VkDescriptorPoolCreateFlagBits */
1514 
1515 static inline size_t
vn_sizeof_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits * val)1516 vn_sizeof_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits *val)
1517 {
1518     assert(sizeof(*val) == sizeof(int32_t));
1519     return vn_sizeof_int32_t((const int32_t *)val);
1520 }
1521 
1522 static inline void
vn_encode_VkDescriptorPoolCreateFlagBits(struct vn_cs_encoder * enc,const VkDescriptorPoolCreateFlagBits * val)1523 vn_encode_VkDescriptorPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateFlagBits *val)
1524 {
1525     vn_encode_int32_t(enc, (const int32_t *)val);
1526 }
1527 
1528 static inline void
vn_decode_VkDescriptorPoolCreateFlagBits(struct vn_cs_decoder * dec,VkDescriptorPoolCreateFlagBits * val)1529 vn_decode_VkDescriptorPoolCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorPoolCreateFlagBits *val)
1530 {
1531     vn_decode_int32_t(dec, (int32_t *)val);
1532 }
1533 
1534 /* enum VkDependencyFlagBits */
1535 
1536 static inline size_t
vn_sizeof_VkDependencyFlagBits(const VkDependencyFlagBits * val)1537 vn_sizeof_VkDependencyFlagBits(const VkDependencyFlagBits *val)
1538 {
1539     assert(sizeof(*val) == sizeof(int32_t));
1540     return vn_sizeof_int32_t((const int32_t *)val);
1541 }
1542 
1543 static inline void
vn_encode_VkDependencyFlagBits(struct vn_cs_encoder * enc,const VkDependencyFlagBits * val)1544 vn_encode_VkDependencyFlagBits(struct vn_cs_encoder *enc, const VkDependencyFlagBits *val)
1545 {
1546     vn_encode_int32_t(enc, (const int32_t *)val);
1547 }
1548 
1549 static inline void
vn_decode_VkDependencyFlagBits(struct vn_cs_decoder * dec,VkDependencyFlagBits * val)1550 vn_decode_VkDependencyFlagBits(struct vn_cs_decoder *dec, VkDependencyFlagBits *val)
1551 {
1552     vn_decode_int32_t(dec, (int32_t *)val);
1553 }
1554 
1555 /* enum VkSubgroupFeatureFlagBits */
1556 
1557 static inline size_t
vn_sizeof_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits * val)1558 vn_sizeof_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits *val)
1559 {
1560     assert(sizeof(*val) == sizeof(int32_t));
1561     return vn_sizeof_int32_t((const int32_t *)val);
1562 }
1563 
1564 static inline void
vn_encode_VkSubgroupFeatureFlagBits(struct vn_cs_encoder * enc,const VkSubgroupFeatureFlagBits * val)1565 vn_encode_VkSubgroupFeatureFlagBits(struct vn_cs_encoder *enc, const VkSubgroupFeatureFlagBits *val)
1566 {
1567     vn_encode_int32_t(enc, (const int32_t *)val);
1568 }
1569 
1570 static inline void
vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder * dec,VkSubgroupFeatureFlagBits * val)1571 vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder *dec, VkSubgroupFeatureFlagBits *val)
1572 {
1573     vn_decode_int32_t(dec, (int32_t *)val);
1574 }
1575 
1576 /* enum VkPipelineCreationFeedbackFlagBits */
1577 
1578 static inline size_t
vn_sizeof_VkPipelineCreationFeedbackFlagBits(const VkPipelineCreationFeedbackFlagBits * val)1579 vn_sizeof_VkPipelineCreationFeedbackFlagBits(const VkPipelineCreationFeedbackFlagBits *val)
1580 {
1581     assert(sizeof(*val) == sizeof(int32_t));
1582     return vn_sizeof_int32_t((const int32_t *)val);
1583 }
1584 
1585 static inline void
vn_encode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_encoder * enc,const VkPipelineCreationFeedbackFlagBits * val)1586 vn_encode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackFlagBits *val)
1587 {
1588     vn_encode_int32_t(enc, (const int32_t *)val);
1589 }
1590 
1591 static inline void
vn_decode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_decoder * dec,VkPipelineCreationFeedbackFlagBits * val)1592 vn_decode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackFlagBits *val)
1593 {
1594     vn_decode_int32_t(dec, (int32_t *)val);
1595 }
1596 
1597 /* enum VkSemaphoreWaitFlagBits */
1598 
1599 static inline size_t
vn_sizeof_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits * val)1600 vn_sizeof_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits *val)
1601 {
1602     assert(sizeof(*val) == sizeof(int32_t));
1603     return vn_sizeof_int32_t((const int32_t *)val);
1604 }
1605 
1606 static inline void
vn_encode_VkSemaphoreWaitFlagBits(struct vn_cs_encoder * enc,const VkSemaphoreWaitFlagBits * val)1607 vn_encode_VkSemaphoreWaitFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreWaitFlagBits *val)
1608 {
1609     vn_encode_int32_t(enc, (const int32_t *)val);
1610 }
1611 
1612 static inline void
vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder * dec,VkSemaphoreWaitFlagBits * val)1613 vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder *dec, VkSemaphoreWaitFlagBits *val)
1614 {
1615     vn_decode_int32_t(dec, (int32_t *)val);
1616 }
1617 
1618 /* typedef VkFlags64 VkAccessFlagBits2 */
1619 
1620 static inline size_t
vn_sizeof_VkAccessFlagBits2(const VkAccessFlagBits2 * val)1621 vn_sizeof_VkAccessFlagBits2(const VkAccessFlagBits2 *val)
1622 {
1623     assert(sizeof(*val) == sizeof(uint64_t));
1624     return vn_sizeof_uint64_t((const uint64_t *)val);
1625 }
1626 
1627 static inline void
vn_encode_VkAccessFlagBits2(struct vn_cs_encoder * enc,const VkAccessFlagBits2 * val)1628 vn_encode_VkAccessFlagBits2(struct vn_cs_encoder *enc, const VkAccessFlagBits2 *val)
1629 {
1630     vn_encode_uint64_t(enc, (const uint64_t *)val);
1631 }
1632 
1633 static inline void
vn_decode_VkAccessFlagBits2(struct vn_cs_decoder * dec,VkAccessFlagBits2 * val)1634 vn_decode_VkAccessFlagBits2(struct vn_cs_decoder *dec, VkAccessFlagBits2 *val)
1635 {
1636     vn_decode_uint64_t(dec, (uint64_t *)val);
1637 }
1638 
1639 /* typedef VkFlags64 VkPipelineStageFlagBits2 */
1640 
1641 static inline size_t
vn_sizeof_VkPipelineStageFlagBits2(const VkPipelineStageFlagBits2 * val)1642 vn_sizeof_VkPipelineStageFlagBits2(const VkPipelineStageFlagBits2 *val)
1643 {
1644     assert(sizeof(*val) == sizeof(uint64_t));
1645     return vn_sizeof_uint64_t((const uint64_t *)val);
1646 }
1647 
1648 static inline void
vn_encode_VkPipelineStageFlagBits2(struct vn_cs_encoder * enc,const VkPipelineStageFlagBits2 * val)1649 vn_encode_VkPipelineStageFlagBits2(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits2 *val)
1650 {
1651     vn_encode_uint64_t(enc, (const uint64_t *)val);
1652 }
1653 
1654 static inline void
vn_decode_VkPipelineStageFlagBits2(struct vn_cs_decoder * dec,VkPipelineStageFlagBits2 * val)1655 vn_decode_VkPipelineStageFlagBits2(struct vn_cs_decoder *dec, VkPipelineStageFlagBits2 *val)
1656 {
1657     vn_decode_uint64_t(dec, (uint64_t *)val);
1658 }
1659 
1660 /* typedef VkFlags64 VkFormatFeatureFlagBits2 */
1661 
1662 static inline size_t
vn_sizeof_VkFormatFeatureFlagBits2(const VkFormatFeatureFlagBits2 * val)1663 vn_sizeof_VkFormatFeatureFlagBits2(const VkFormatFeatureFlagBits2 *val)
1664 {
1665     assert(sizeof(*val) == sizeof(uint64_t));
1666     return vn_sizeof_uint64_t((const uint64_t *)val);
1667 }
1668 
1669 static inline void
vn_encode_VkFormatFeatureFlagBits2(struct vn_cs_encoder * enc,const VkFormatFeatureFlagBits2 * val)1670 vn_encode_VkFormatFeatureFlagBits2(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits2 *val)
1671 {
1672     vn_encode_uint64_t(enc, (const uint64_t *)val);
1673 }
1674 
1675 static inline void
vn_decode_VkFormatFeatureFlagBits2(struct vn_cs_decoder * dec,VkFormatFeatureFlagBits2 * val)1676 vn_decode_VkFormatFeatureFlagBits2(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits2 *val)
1677 {
1678     vn_decode_uint64_t(dec, (uint64_t *)val);
1679 }
1680 
1681 /* enum VkRenderingFlagBits */
1682 
1683 static inline size_t
vn_sizeof_VkRenderingFlagBits(const VkRenderingFlagBits * val)1684 vn_sizeof_VkRenderingFlagBits(const VkRenderingFlagBits *val)
1685 {
1686     assert(sizeof(*val) == sizeof(int32_t));
1687     return vn_sizeof_int32_t((const int32_t *)val);
1688 }
1689 
1690 static inline void
vn_encode_VkRenderingFlagBits(struct vn_cs_encoder * enc,const VkRenderingFlagBits * val)1691 vn_encode_VkRenderingFlagBits(struct vn_cs_encoder *enc, const VkRenderingFlagBits *val)
1692 {
1693     vn_encode_int32_t(enc, (const int32_t *)val);
1694 }
1695 
1696 static inline void
vn_decode_VkRenderingFlagBits(struct vn_cs_decoder * dec,VkRenderingFlagBits * val)1697 vn_decode_VkRenderingFlagBits(struct vn_cs_decoder *dec, VkRenderingFlagBits *val)
1698 {
1699     vn_decode_int32_t(dec, (int32_t *)val);
1700 }
1701 
1702 /* enum VkPeerMemoryFeatureFlagBits */
1703 
1704 static inline size_t
vn_sizeof_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits * val)1705 vn_sizeof_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits *val)
1706 {
1707     assert(sizeof(*val) == sizeof(int32_t));
1708     return vn_sizeof_int32_t((const int32_t *)val);
1709 }
1710 
1711 static inline void
vn_encode_VkPeerMemoryFeatureFlagBits(struct vn_cs_encoder * enc,const VkPeerMemoryFeatureFlagBits * val)1712 vn_encode_VkPeerMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkPeerMemoryFeatureFlagBits *val)
1713 {
1714     vn_encode_int32_t(enc, (const int32_t *)val);
1715 }
1716 
1717 static inline void
vn_decode_VkPeerMemoryFeatureFlagBits(struct vn_cs_decoder * dec,VkPeerMemoryFeatureFlagBits * val)1718 vn_decode_VkPeerMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkPeerMemoryFeatureFlagBits *val)
1719 {
1720     vn_decode_int32_t(dec, (int32_t *)val);
1721 }
1722 
1723 /* enum VkMemoryAllocateFlagBits */
1724 
1725 static inline size_t
vn_sizeof_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits * val)1726 vn_sizeof_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits *val)
1727 {
1728     assert(sizeof(*val) == sizeof(int32_t));
1729     return vn_sizeof_int32_t((const int32_t *)val);
1730 }
1731 
1732 static inline void
vn_encode_VkMemoryAllocateFlagBits(struct vn_cs_encoder * enc,const VkMemoryAllocateFlagBits * val)1733 vn_encode_VkMemoryAllocateFlagBits(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagBits *val)
1734 {
1735     vn_encode_int32_t(enc, (const int32_t *)val);
1736 }
1737 
1738 static inline void
vn_decode_VkMemoryAllocateFlagBits(struct vn_cs_decoder * dec,VkMemoryAllocateFlagBits * val)1739 vn_decode_VkMemoryAllocateFlagBits(struct vn_cs_decoder *dec, VkMemoryAllocateFlagBits *val)
1740 {
1741     vn_decode_int32_t(dec, (int32_t *)val);
1742 }
1743 
1744 /* enum VkExternalMemoryHandleTypeFlagBits */
1745 
1746 static inline size_t
vn_sizeof_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits * val)1747 vn_sizeof_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits *val)
1748 {
1749     assert(sizeof(*val) == sizeof(int32_t));
1750     return vn_sizeof_int32_t((const int32_t *)val);
1751 }
1752 
1753 static inline void
vn_encode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_encoder * enc,const VkExternalMemoryHandleTypeFlagBits * val)1754 vn_encode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryHandleTypeFlagBits *val)
1755 {
1756     vn_encode_int32_t(enc, (const int32_t *)val);
1757 }
1758 
1759 static inline void
vn_decode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_decoder * dec,VkExternalMemoryHandleTypeFlagBits * val)1760 vn_decode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryHandleTypeFlagBits *val)
1761 {
1762     vn_decode_int32_t(dec, (int32_t *)val);
1763 }
1764 
1765 /* enum VkExternalMemoryFeatureFlagBits */
1766 
1767 static inline size_t
vn_sizeof_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits * val)1768 vn_sizeof_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits *val)
1769 {
1770     assert(sizeof(*val) == sizeof(int32_t));
1771     return vn_sizeof_int32_t((const int32_t *)val);
1772 }
1773 
1774 static inline void
vn_encode_VkExternalMemoryFeatureFlagBits(struct vn_cs_encoder * enc,const VkExternalMemoryFeatureFlagBits * val)1775 vn_encode_VkExternalMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryFeatureFlagBits *val)
1776 {
1777     vn_encode_int32_t(enc, (const int32_t *)val);
1778 }
1779 
1780 static inline void
vn_decode_VkExternalMemoryFeatureFlagBits(struct vn_cs_decoder * dec,VkExternalMemoryFeatureFlagBits * val)1781 vn_decode_VkExternalMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryFeatureFlagBits *val)
1782 {
1783     vn_decode_int32_t(dec, (int32_t *)val);
1784 }
1785 
1786 /* enum VkExternalSemaphoreHandleTypeFlagBits */
1787 
1788 static inline size_t
vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits * val)1789 vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits *val)
1790 {
1791     assert(sizeof(*val) == sizeof(int32_t));
1792     return vn_sizeof_int32_t((const int32_t *)val);
1793 }
1794 
1795 static inline void
vn_encode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_encoder * enc,const VkExternalSemaphoreHandleTypeFlagBits * val)1796 vn_encode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreHandleTypeFlagBits *val)
1797 {
1798     vn_encode_int32_t(enc, (const int32_t *)val);
1799 }
1800 
1801 static inline void
vn_decode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_decoder * dec,VkExternalSemaphoreHandleTypeFlagBits * val)1802 vn_decode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreHandleTypeFlagBits *val)
1803 {
1804     vn_decode_int32_t(dec, (int32_t *)val);
1805 }
1806 
1807 /* enum VkExternalSemaphoreFeatureFlagBits */
1808 
1809 static inline size_t
vn_sizeof_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits * val)1810 vn_sizeof_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits *val)
1811 {
1812     assert(sizeof(*val) == sizeof(int32_t));
1813     return vn_sizeof_int32_t((const int32_t *)val);
1814 }
1815 
1816 static inline void
vn_encode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_encoder * enc,const VkExternalSemaphoreFeatureFlagBits * val)1817 vn_encode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreFeatureFlagBits *val)
1818 {
1819     vn_encode_int32_t(enc, (const int32_t *)val);
1820 }
1821 
1822 static inline void
vn_decode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_decoder * dec,VkExternalSemaphoreFeatureFlagBits * val)1823 vn_decode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreFeatureFlagBits *val)
1824 {
1825     vn_decode_int32_t(dec, (int32_t *)val);
1826 }
1827 
1828 /* enum VkSemaphoreImportFlagBits */
1829 
1830 static inline size_t
vn_sizeof_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits * val)1831 vn_sizeof_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits *val)
1832 {
1833     assert(sizeof(*val) == sizeof(int32_t));
1834     return vn_sizeof_int32_t((const int32_t *)val);
1835 }
1836 
1837 static inline void
vn_encode_VkSemaphoreImportFlagBits(struct vn_cs_encoder * enc,const VkSemaphoreImportFlagBits * val)1838 vn_encode_VkSemaphoreImportFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreImportFlagBits *val)
1839 {
1840     vn_encode_int32_t(enc, (const int32_t *)val);
1841 }
1842 
1843 static inline void
vn_decode_VkSemaphoreImportFlagBits(struct vn_cs_decoder * dec,VkSemaphoreImportFlagBits * val)1844 vn_decode_VkSemaphoreImportFlagBits(struct vn_cs_decoder *dec, VkSemaphoreImportFlagBits *val)
1845 {
1846     vn_decode_int32_t(dec, (int32_t *)val);
1847 }
1848 
1849 /* enum VkExternalFenceHandleTypeFlagBits */
1850 
1851 static inline size_t
vn_sizeof_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits * val)1852 vn_sizeof_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits *val)
1853 {
1854     assert(sizeof(*val) == sizeof(int32_t));
1855     return vn_sizeof_int32_t((const int32_t *)val);
1856 }
1857 
1858 static inline void
vn_encode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_encoder * enc,const VkExternalFenceHandleTypeFlagBits * val)1859 vn_encode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceHandleTypeFlagBits *val)
1860 {
1861     vn_encode_int32_t(enc, (const int32_t *)val);
1862 }
1863 
1864 static inline void
vn_decode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_decoder * dec,VkExternalFenceHandleTypeFlagBits * val)1865 vn_decode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalFenceHandleTypeFlagBits *val)
1866 {
1867     vn_decode_int32_t(dec, (int32_t *)val);
1868 }
1869 
1870 /* enum VkExternalFenceFeatureFlagBits */
1871 
1872 static inline size_t
vn_sizeof_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits * val)1873 vn_sizeof_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits *val)
1874 {
1875     assert(sizeof(*val) == sizeof(int32_t));
1876     return vn_sizeof_int32_t((const int32_t *)val);
1877 }
1878 
1879 static inline void
vn_encode_VkExternalFenceFeatureFlagBits(struct vn_cs_encoder * enc,const VkExternalFenceFeatureFlagBits * val)1880 vn_encode_VkExternalFenceFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceFeatureFlagBits *val)
1881 {
1882     vn_encode_int32_t(enc, (const int32_t *)val);
1883 }
1884 
1885 static inline void
vn_decode_VkExternalFenceFeatureFlagBits(struct vn_cs_decoder * dec,VkExternalFenceFeatureFlagBits * val)1886 vn_decode_VkExternalFenceFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalFenceFeatureFlagBits *val)
1887 {
1888     vn_decode_int32_t(dec, (int32_t *)val);
1889 }
1890 
1891 /* enum VkFenceImportFlagBits */
1892 
1893 static inline size_t
vn_sizeof_VkFenceImportFlagBits(const VkFenceImportFlagBits * val)1894 vn_sizeof_VkFenceImportFlagBits(const VkFenceImportFlagBits *val)
1895 {
1896     assert(sizeof(*val) == sizeof(int32_t));
1897     return vn_sizeof_int32_t((const int32_t *)val);
1898 }
1899 
1900 static inline void
vn_encode_VkFenceImportFlagBits(struct vn_cs_encoder * enc,const VkFenceImportFlagBits * val)1901 vn_encode_VkFenceImportFlagBits(struct vn_cs_encoder *enc, const VkFenceImportFlagBits *val)
1902 {
1903     vn_encode_int32_t(enc, (const int32_t *)val);
1904 }
1905 
1906 static inline void
vn_decode_VkFenceImportFlagBits(struct vn_cs_decoder * dec,VkFenceImportFlagBits * val)1907 vn_decode_VkFenceImportFlagBits(struct vn_cs_decoder *dec, VkFenceImportFlagBits *val)
1908 {
1909     vn_decode_int32_t(dec, (int32_t *)val);
1910 }
1911 
1912 /* enum VkDescriptorBindingFlagBits */
1913 
1914 static inline size_t
vn_sizeof_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits * val)1915 vn_sizeof_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits *val)
1916 {
1917     assert(sizeof(*val) == sizeof(int32_t));
1918     return vn_sizeof_int32_t((const int32_t *)val);
1919 }
1920 
1921 static inline void
vn_encode_VkDescriptorBindingFlagBits(struct vn_cs_encoder * enc,const VkDescriptorBindingFlagBits * val)1922 vn_encode_VkDescriptorBindingFlagBits(struct vn_cs_encoder *enc, const VkDescriptorBindingFlagBits *val)
1923 {
1924     vn_encode_int32_t(enc, (const int32_t *)val);
1925 }
1926 
1927 static inline void
vn_decode_VkDescriptorBindingFlagBits(struct vn_cs_decoder * dec,VkDescriptorBindingFlagBits * val)1928 vn_decode_VkDescriptorBindingFlagBits(struct vn_cs_decoder *dec, VkDescriptorBindingFlagBits *val)
1929 {
1930     vn_decode_int32_t(dec, (int32_t *)val);
1931 }
1932 
1933 /* enum VkConditionalRenderingFlagBitsEXT */
1934 
1935 static inline size_t
vn_sizeof_VkConditionalRenderingFlagBitsEXT(const VkConditionalRenderingFlagBitsEXT * val)1936 vn_sizeof_VkConditionalRenderingFlagBitsEXT(const VkConditionalRenderingFlagBitsEXT *val)
1937 {
1938     assert(sizeof(*val) == sizeof(int32_t));
1939     return vn_sizeof_int32_t((const int32_t *)val);
1940 }
1941 
1942 static inline void
vn_encode_VkConditionalRenderingFlagBitsEXT(struct vn_cs_encoder * enc,const VkConditionalRenderingFlagBitsEXT * val)1943 vn_encode_VkConditionalRenderingFlagBitsEXT(struct vn_cs_encoder *enc, const VkConditionalRenderingFlagBitsEXT *val)
1944 {
1945     vn_encode_int32_t(enc, (const int32_t *)val);
1946 }
1947 
1948 static inline void
vn_decode_VkConditionalRenderingFlagBitsEXT(struct vn_cs_decoder * dec,VkConditionalRenderingFlagBitsEXT * val)1949 vn_decode_VkConditionalRenderingFlagBitsEXT(struct vn_cs_decoder *dec, VkConditionalRenderingFlagBitsEXT *val)
1950 {
1951     vn_decode_int32_t(dec, (int32_t *)val);
1952 }
1953 
1954 /* enum VkResolveModeFlagBits */
1955 
1956 static inline size_t
vn_sizeof_VkResolveModeFlagBits(const VkResolveModeFlagBits * val)1957 vn_sizeof_VkResolveModeFlagBits(const VkResolveModeFlagBits *val)
1958 {
1959     assert(sizeof(*val) == sizeof(int32_t));
1960     return vn_sizeof_int32_t((const int32_t *)val);
1961 }
1962 
1963 static inline void
vn_encode_VkResolveModeFlagBits(struct vn_cs_encoder * enc,const VkResolveModeFlagBits * val)1964 vn_encode_VkResolveModeFlagBits(struct vn_cs_encoder *enc, const VkResolveModeFlagBits *val)
1965 {
1966     vn_encode_int32_t(enc, (const int32_t *)val);
1967 }
1968 
1969 static inline void
vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder * dec,VkResolveModeFlagBits * val)1970 vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder *dec, VkResolveModeFlagBits *val)
1971 {
1972     vn_decode_int32_t(dec, (int32_t *)val);
1973 }
1974 
1975 /* enum VkToolPurposeFlagBits */
1976 
1977 static inline size_t
vn_sizeof_VkToolPurposeFlagBits(const VkToolPurposeFlagBits * val)1978 vn_sizeof_VkToolPurposeFlagBits(const VkToolPurposeFlagBits *val)
1979 {
1980     assert(sizeof(*val) == sizeof(int32_t));
1981     return vn_sizeof_int32_t((const int32_t *)val);
1982 }
1983 
1984 static inline void
vn_encode_VkToolPurposeFlagBits(struct vn_cs_encoder * enc,const VkToolPurposeFlagBits * val)1985 vn_encode_VkToolPurposeFlagBits(struct vn_cs_encoder *enc, const VkToolPurposeFlagBits *val)
1986 {
1987     vn_encode_int32_t(enc, (const int32_t *)val);
1988 }
1989 
1990 static inline void
vn_decode_VkToolPurposeFlagBits(struct vn_cs_decoder * dec,VkToolPurposeFlagBits * val)1991 vn_decode_VkToolPurposeFlagBits(struct vn_cs_decoder *dec, VkToolPurposeFlagBits *val)
1992 {
1993     vn_decode_int32_t(dec, (int32_t *)val);
1994 }
1995 
1996 /* enum VkSubmitFlagBits */
1997 
1998 static inline size_t
vn_sizeof_VkSubmitFlagBits(const VkSubmitFlagBits * val)1999 vn_sizeof_VkSubmitFlagBits(const VkSubmitFlagBits *val)
2000 {
2001     assert(sizeof(*val) == sizeof(int32_t));
2002     return vn_sizeof_int32_t((const int32_t *)val);
2003 }
2004 
2005 static inline void
vn_encode_VkSubmitFlagBits(struct vn_cs_encoder * enc,const VkSubmitFlagBits * val)2006 vn_encode_VkSubmitFlagBits(struct vn_cs_encoder *enc, const VkSubmitFlagBits *val)
2007 {
2008     vn_encode_int32_t(enc, (const int32_t *)val);
2009 }
2010 
2011 static inline void
vn_decode_VkSubmitFlagBits(struct vn_cs_decoder * dec,VkSubmitFlagBits * val)2012 vn_decode_VkSubmitFlagBits(struct vn_cs_decoder *dec, VkSubmitFlagBits *val)
2013 {
2014     vn_decode_int32_t(dec, (int32_t *)val);
2015 }
2016 
2017 /* enum VkAttachmentLoadOp */
2018 
2019 static inline size_t
vn_sizeof_VkAttachmentLoadOp(const VkAttachmentLoadOp * val)2020 vn_sizeof_VkAttachmentLoadOp(const VkAttachmentLoadOp *val)
2021 {
2022     assert(sizeof(*val) == sizeof(int32_t));
2023     return vn_sizeof_int32_t((const int32_t *)val);
2024 }
2025 
2026 static inline void
vn_encode_VkAttachmentLoadOp(struct vn_cs_encoder * enc,const VkAttachmentLoadOp * val)2027 vn_encode_VkAttachmentLoadOp(struct vn_cs_encoder *enc, const VkAttachmentLoadOp *val)
2028 {
2029     vn_encode_int32_t(enc, (const int32_t *)val);
2030 }
2031 
2032 static inline void
vn_decode_VkAttachmentLoadOp(struct vn_cs_decoder * dec,VkAttachmentLoadOp * val)2033 vn_decode_VkAttachmentLoadOp(struct vn_cs_decoder *dec, VkAttachmentLoadOp *val)
2034 {
2035     vn_decode_int32_t(dec, (int32_t *)val);
2036 }
2037 
2038 /* enum VkAttachmentStoreOp */
2039 
2040 static inline size_t
vn_sizeof_VkAttachmentStoreOp(const VkAttachmentStoreOp * val)2041 vn_sizeof_VkAttachmentStoreOp(const VkAttachmentStoreOp *val)
2042 {
2043     assert(sizeof(*val) == sizeof(int32_t));
2044     return vn_sizeof_int32_t((const int32_t *)val);
2045 }
2046 
2047 static inline void
vn_encode_VkAttachmentStoreOp(struct vn_cs_encoder * enc,const VkAttachmentStoreOp * val)2048 vn_encode_VkAttachmentStoreOp(struct vn_cs_encoder *enc, const VkAttachmentStoreOp *val)
2049 {
2050     vn_encode_int32_t(enc, (const int32_t *)val);
2051 }
2052 
2053 static inline void
vn_decode_VkAttachmentStoreOp(struct vn_cs_decoder * dec,VkAttachmentStoreOp * val)2054 vn_decode_VkAttachmentStoreOp(struct vn_cs_decoder *dec, VkAttachmentStoreOp *val)
2055 {
2056     vn_decode_int32_t(dec, (int32_t *)val);
2057 }
2058 
2059 /* enum VkBlendFactor */
2060 
2061 static inline size_t
vn_sizeof_VkBlendFactor(const VkBlendFactor * val)2062 vn_sizeof_VkBlendFactor(const VkBlendFactor *val)
2063 {
2064     assert(sizeof(*val) == sizeof(int32_t));
2065     return vn_sizeof_int32_t((const int32_t *)val);
2066 }
2067 
2068 static inline void
vn_encode_VkBlendFactor(struct vn_cs_encoder * enc,const VkBlendFactor * val)2069 vn_encode_VkBlendFactor(struct vn_cs_encoder *enc, const VkBlendFactor *val)
2070 {
2071     vn_encode_int32_t(enc, (const int32_t *)val);
2072 }
2073 
2074 static inline void
vn_decode_VkBlendFactor(struct vn_cs_decoder * dec,VkBlendFactor * val)2075 vn_decode_VkBlendFactor(struct vn_cs_decoder *dec, VkBlendFactor *val)
2076 {
2077     vn_decode_int32_t(dec, (int32_t *)val);
2078 }
2079 
2080 /* enum VkBlendOp */
2081 
2082 static inline size_t
vn_sizeof_VkBlendOp(const VkBlendOp * val)2083 vn_sizeof_VkBlendOp(const VkBlendOp *val)
2084 {
2085     assert(sizeof(*val) == sizeof(int32_t));
2086     return vn_sizeof_int32_t((const int32_t *)val);
2087 }
2088 
2089 static inline void
vn_encode_VkBlendOp(struct vn_cs_encoder * enc,const VkBlendOp * val)2090 vn_encode_VkBlendOp(struct vn_cs_encoder *enc, const VkBlendOp *val)
2091 {
2092     vn_encode_int32_t(enc, (const int32_t *)val);
2093 }
2094 
2095 static inline void
vn_decode_VkBlendOp(struct vn_cs_decoder * dec,VkBlendOp * val)2096 vn_decode_VkBlendOp(struct vn_cs_decoder *dec, VkBlendOp *val)
2097 {
2098     vn_decode_int32_t(dec, (int32_t *)val);
2099 }
2100 
2101 /* enum VkBorderColor */
2102 
2103 static inline size_t
vn_sizeof_VkBorderColor(const VkBorderColor * val)2104 vn_sizeof_VkBorderColor(const VkBorderColor *val)
2105 {
2106     assert(sizeof(*val) == sizeof(int32_t));
2107     return vn_sizeof_int32_t((const int32_t *)val);
2108 }
2109 
2110 static inline void
vn_encode_VkBorderColor(struct vn_cs_encoder * enc,const VkBorderColor * val)2111 vn_encode_VkBorderColor(struct vn_cs_encoder *enc, const VkBorderColor *val)
2112 {
2113     vn_encode_int32_t(enc, (const int32_t *)val);
2114 }
2115 
2116 static inline void
vn_decode_VkBorderColor(struct vn_cs_decoder * dec,VkBorderColor * val)2117 vn_decode_VkBorderColor(struct vn_cs_decoder *dec, VkBorderColor *val)
2118 {
2119     vn_decode_int32_t(dec, (int32_t *)val);
2120 }
2121 
2122 /* enum VkPipelineCacheHeaderVersion */
2123 
2124 static inline size_t
vn_sizeof_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion * val)2125 vn_sizeof_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion *val)
2126 {
2127     assert(sizeof(*val) == sizeof(int32_t));
2128     return vn_sizeof_int32_t((const int32_t *)val);
2129 }
2130 
2131 static inline void
vn_encode_VkPipelineCacheHeaderVersion(struct vn_cs_encoder * enc,const VkPipelineCacheHeaderVersion * val)2132 vn_encode_VkPipelineCacheHeaderVersion(struct vn_cs_encoder *enc, const VkPipelineCacheHeaderVersion *val)
2133 {
2134     vn_encode_int32_t(enc, (const int32_t *)val);
2135 }
2136 
2137 static inline void
vn_decode_VkPipelineCacheHeaderVersion(struct vn_cs_decoder * dec,VkPipelineCacheHeaderVersion * val)2138 vn_decode_VkPipelineCacheHeaderVersion(struct vn_cs_decoder *dec, VkPipelineCacheHeaderVersion *val)
2139 {
2140     vn_decode_int32_t(dec, (int32_t *)val);
2141 }
2142 
2143 /* enum VkComponentSwizzle */
2144 
2145 static inline size_t
vn_sizeof_VkComponentSwizzle(const VkComponentSwizzle * val)2146 vn_sizeof_VkComponentSwizzle(const VkComponentSwizzle *val)
2147 {
2148     assert(sizeof(*val) == sizeof(int32_t));
2149     return vn_sizeof_int32_t((const int32_t *)val);
2150 }
2151 
2152 static inline void
vn_encode_VkComponentSwizzle(struct vn_cs_encoder * enc,const VkComponentSwizzle * val)2153 vn_encode_VkComponentSwizzle(struct vn_cs_encoder *enc, const VkComponentSwizzle *val)
2154 {
2155     vn_encode_int32_t(enc, (const int32_t *)val);
2156 }
2157 
2158 static inline void
vn_decode_VkComponentSwizzle(struct vn_cs_decoder * dec,VkComponentSwizzle * val)2159 vn_decode_VkComponentSwizzle(struct vn_cs_decoder *dec, VkComponentSwizzle *val)
2160 {
2161     vn_decode_int32_t(dec, (int32_t *)val);
2162 }
2163 
2164 /* enum VkCommandBufferLevel */
2165 
2166 static inline size_t
vn_sizeof_VkCommandBufferLevel(const VkCommandBufferLevel * val)2167 vn_sizeof_VkCommandBufferLevel(const VkCommandBufferLevel *val)
2168 {
2169     assert(sizeof(*val) == sizeof(int32_t));
2170     return vn_sizeof_int32_t((const int32_t *)val);
2171 }
2172 
2173 static inline void
vn_encode_VkCommandBufferLevel(struct vn_cs_encoder * enc,const VkCommandBufferLevel * val)2174 vn_encode_VkCommandBufferLevel(struct vn_cs_encoder *enc, const VkCommandBufferLevel *val)
2175 {
2176     vn_encode_int32_t(enc, (const int32_t *)val);
2177 }
2178 
2179 static inline void
vn_decode_VkCommandBufferLevel(struct vn_cs_decoder * dec,VkCommandBufferLevel * val)2180 vn_decode_VkCommandBufferLevel(struct vn_cs_decoder *dec, VkCommandBufferLevel *val)
2181 {
2182     vn_decode_int32_t(dec, (int32_t *)val);
2183 }
2184 
2185 /* enum VkCompareOp */
2186 
2187 static inline size_t
vn_sizeof_VkCompareOp(const VkCompareOp * val)2188 vn_sizeof_VkCompareOp(const VkCompareOp *val)
2189 {
2190     assert(sizeof(*val) == sizeof(int32_t));
2191     return vn_sizeof_int32_t((const int32_t *)val);
2192 }
2193 
2194 static inline void
vn_encode_VkCompareOp(struct vn_cs_encoder * enc,const VkCompareOp * val)2195 vn_encode_VkCompareOp(struct vn_cs_encoder *enc, const VkCompareOp *val)
2196 {
2197     vn_encode_int32_t(enc, (const int32_t *)val);
2198 }
2199 
2200 static inline void
vn_decode_VkCompareOp(struct vn_cs_decoder * dec,VkCompareOp * val)2201 vn_decode_VkCompareOp(struct vn_cs_decoder *dec, VkCompareOp *val)
2202 {
2203     vn_decode_int32_t(dec, (int32_t *)val);
2204 }
2205 
2206 /* enum VkDescriptorType */
2207 
2208 static inline size_t
vn_sizeof_VkDescriptorType(const VkDescriptorType * val)2209 vn_sizeof_VkDescriptorType(const VkDescriptorType *val)
2210 {
2211     assert(sizeof(*val) == sizeof(int32_t));
2212     return vn_sizeof_int32_t((const int32_t *)val);
2213 }
2214 
2215 static inline void
vn_encode_VkDescriptorType(struct vn_cs_encoder * enc,const VkDescriptorType * val)2216 vn_encode_VkDescriptorType(struct vn_cs_encoder *enc, const VkDescriptorType *val)
2217 {
2218     vn_encode_int32_t(enc, (const int32_t *)val);
2219 }
2220 
2221 static inline void
vn_decode_VkDescriptorType(struct vn_cs_decoder * dec,VkDescriptorType * val)2222 vn_decode_VkDescriptorType(struct vn_cs_decoder *dec, VkDescriptorType *val)
2223 {
2224     vn_decode_int32_t(dec, (int32_t *)val);
2225 }
2226 
2227 static inline size_t
vn_sizeof_VkDescriptorType_array(const VkDescriptorType * val,uint32_t count)2228 vn_sizeof_VkDescriptorType_array(const VkDescriptorType *val, uint32_t count)
2229 {
2230     return vn_sizeof_int32_t_array((const int32_t *)val, count);
2231 }
2232 
2233 static inline void
vn_encode_VkDescriptorType_array(struct vn_cs_encoder * enc,const VkDescriptorType * val,uint32_t count)2234 vn_encode_VkDescriptorType_array(struct vn_cs_encoder *enc, const VkDescriptorType *val, uint32_t count)
2235 {
2236     vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2237 }
2238 
2239 static inline void
vn_decode_VkDescriptorType_array(struct vn_cs_decoder * dec,VkDescriptorType * val,uint32_t count)2240 vn_decode_VkDescriptorType_array(struct vn_cs_decoder *dec, VkDescriptorType *val, uint32_t count)
2241 {
2242     vn_decode_int32_t_array(dec, (int32_t *)val, count);
2243 }
2244 
2245 /* enum VkDynamicState */
2246 
2247 static inline size_t
vn_sizeof_VkDynamicState(const VkDynamicState * val)2248 vn_sizeof_VkDynamicState(const VkDynamicState *val)
2249 {
2250     assert(sizeof(*val) == sizeof(int32_t));
2251     return vn_sizeof_int32_t((const int32_t *)val);
2252 }
2253 
2254 static inline void
vn_encode_VkDynamicState(struct vn_cs_encoder * enc,const VkDynamicState * val)2255 vn_encode_VkDynamicState(struct vn_cs_encoder *enc, const VkDynamicState *val)
2256 {
2257     vn_encode_int32_t(enc, (const int32_t *)val);
2258 }
2259 
2260 static inline void
vn_decode_VkDynamicState(struct vn_cs_decoder * dec,VkDynamicState * val)2261 vn_decode_VkDynamicState(struct vn_cs_decoder *dec, VkDynamicState *val)
2262 {
2263     vn_decode_int32_t(dec, (int32_t *)val);
2264 }
2265 
2266 static inline size_t
vn_sizeof_VkDynamicState_array(const VkDynamicState * val,uint32_t count)2267 vn_sizeof_VkDynamicState_array(const VkDynamicState *val, uint32_t count)
2268 {
2269     return vn_sizeof_int32_t_array((const int32_t *)val, count);
2270 }
2271 
2272 static inline void
vn_encode_VkDynamicState_array(struct vn_cs_encoder * enc,const VkDynamicState * val,uint32_t count)2273 vn_encode_VkDynamicState_array(struct vn_cs_encoder *enc, const VkDynamicState *val, uint32_t count)
2274 {
2275     vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2276 }
2277 
2278 static inline void
vn_decode_VkDynamicState_array(struct vn_cs_decoder * dec,VkDynamicState * val,uint32_t count)2279 vn_decode_VkDynamicState_array(struct vn_cs_decoder *dec, VkDynamicState *val, uint32_t count)
2280 {
2281     vn_decode_int32_t_array(dec, (int32_t *)val, count);
2282 }
2283 
2284 /* enum VkPolygonMode */
2285 
2286 static inline size_t
vn_sizeof_VkPolygonMode(const VkPolygonMode * val)2287 vn_sizeof_VkPolygonMode(const VkPolygonMode *val)
2288 {
2289     assert(sizeof(*val) == sizeof(int32_t));
2290     return vn_sizeof_int32_t((const int32_t *)val);
2291 }
2292 
2293 static inline void
vn_encode_VkPolygonMode(struct vn_cs_encoder * enc,const VkPolygonMode * val)2294 vn_encode_VkPolygonMode(struct vn_cs_encoder *enc, const VkPolygonMode *val)
2295 {
2296     vn_encode_int32_t(enc, (const int32_t *)val);
2297 }
2298 
2299 static inline void
vn_decode_VkPolygonMode(struct vn_cs_decoder * dec,VkPolygonMode * val)2300 vn_decode_VkPolygonMode(struct vn_cs_decoder *dec, VkPolygonMode *val)
2301 {
2302     vn_decode_int32_t(dec, (int32_t *)val);
2303 }
2304 
2305 /* enum VkFormat */
2306 
2307 static inline size_t
vn_sizeof_VkFormat(const VkFormat * val)2308 vn_sizeof_VkFormat(const VkFormat *val)
2309 {
2310     assert(sizeof(*val) == sizeof(int32_t));
2311     return vn_sizeof_int32_t((const int32_t *)val);
2312 }
2313 
2314 static inline void
vn_encode_VkFormat(struct vn_cs_encoder * enc,const VkFormat * val)2315 vn_encode_VkFormat(struct vn_cs_encoder *enc, const VkFormat *val)
2316 {
2317     vn_encode_int32_t(enc, (const int32_t *)val);
2318 }
2319 
2320 static inline void
vn_decode_VkFormat(struct vn_cs_decoder * dec,VkFormat * val)2321 vn_decode_VkFormat(struct vn_cs_decoder *dec, VkFormat *val)
2322 {
2323     vn_decode_int32_t(dec, (int32_t *)val);
2324 }
2325 
2326 static inline size_t
vn_sizeof_VkFormat_array(const VkFormat * val,uint32_t count)2327 vn_sizeof_VkFormat_array(const VkFormat *val, uint32_t count)
2328 {
2329     return vn_sizeof_int32_t_array((const int32_t *)val, count);
2330 }
2331 
2332 static inline void
vn_encode_VkFormat_array(struct vn_cs_encoder * enc,const VkFormat * val,uint32_t count)2333 vn_encode_VkFormat_array(struct vn_cs_encoder *enc, const VkFormat *val, uint32_t count)
2334 {
2335     vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2336 }
2337 
2338 static inline void
vn_decode_VkFormat_array(struct vn_cs_decoder * dec,VkFormat * val,uint32_t count)2339 vn_decode_VkFormat_array(struct vn_cs_decoder *dec, VkFormat *val, uint32_t count)
2340 {
2341     vn_decode_int32_t_array(dec, (int32_t *)val, count);
2342 }
2343 
2344 /* enum VkFrontFace */
2345 
2346 static inline size_t
vn_sizeof_VkFrontFace(const VkFrontFace * val)2347 vn_sizeof_VkFrontFace(const VkFrontFace *val)
2348 {
2349     assert(sizeof(*val) == sizeof(int32_t));
2350     return vn_sizeof_int32_t((const int32_t *)val);
2351 }
2352 
2353 static inline void
vn_encode_VkFrontFace(struct vn_cs_encoder * enc,const VkFrontFace * val)2354 vn_encode_VkFrontFace(struct vn_cs_encoder *enc, const VkFrontFace *val)
2355 {
2356     vn_encode_int32_t(enc, (const int32_t *)val);
2357 }
2358 
2359 static inline void
vn_decode_VkFrontFace(struct vn_cs_decoder * dec,VkFrontFace * val)2360 vn_decode_VkFrontFace(struct vn_cs_decoder *dec, VkFrontFace *val)
2361 {
2362     vn_decode_int32_t(dec, (int32_t *)val);
2363 }
2364 
2365 /* enum VkImageLayout */
2366 
2367 static inline size_t
vn_sizeof_VkImageLayout(const VkImageLayout * val)2368 vn_sizeof_VkImageLayout(const VkImageLayout *val)
2369 {
2370     assert(sizeof(*val) == sizeof(int32_t));
2371     return vn_sizeof_int32_t((const int32_t *)val);
2372 }
2373 
2374 static inline void
vn_encode_VkImageLayout(struct vn_cs_encoder * enc,const VkImageLayout * val)2375 vn_encode_VkImageLayout(struct vn_cs_encoder *enc, const VkImageLayout *val)
2376 {
2377     vn_encode_int32_t(enc, (const int32_t *)val);
2378 }
2379 
2380 static inline void
vn_decode_VkImageLayout(struct vn_cs_decoder * dec,VkImageLayout * val)2381 vn_decode_VkImageLayout(struct vn_cs_decoder *dec, VkImageLayout *val)
2382 {
2383     vn_decode_int32_t(dec, (int32_t *)val);
2384 }
2385 
2386 /* enum VkImageTiling */
2387 
2388 static inline size_t
vn_sizeof_VkImageTiling(const VkImageTiling * val)2389 vn_sizeof_VkImageTiling(const VkImageTiling *val)
2390 {
2391     assert(sizeof(*val) == sizeof(int32_t));
2392     return vn_sizeof_int32_t((const int32_t *)val);
2393 }
2394 
2395 static inline void
vn_encode_VkImageTiling(struct vn_cs_encoder * enc,const VkImageTiling * val)2396 vn_encode_VkImageTiling(struct vn_cs_encoder *enc, const VkImageTiling *val)
2397 {
2398     vn_encode_int32_t(enc, (const int32_t *)val);
2399 }
2400 
2401 static inline void
vn_decode_VkImageTiling(struct vn_cs_decoder * dec,VkImageTiling * val)2402 vn_decode_VkImageTiling(struct vn_cs_decoder *dec, VkImageTiling *val)
2403 {
2404     vn_decode_int32_t(dec, (int32_t *)val);
2405 }
2406 
2407 /* enum VkImageType */
2408 
2409 static inline size_t
vn_sizeof_VkImageType(const VkImageType * val)2410 vn_sizeof_VkImageType(const VkImageType *val)
2411 {
2412     assert(sizeof(*val) == sizeof(int32_t));
2413     return vn_sizeof_int32_t((const int32_t *)val);
2414 }
2415 
2416 static inline void
vn_encode_VkImageType(struct vn_cs_encoder * enc,const VkImageType * val)2417 vn_encode_VkImageType(struct vn_cs_encoder *enc, const VkImageType *val)
2418 {
2419     vn_encode_int32_t(enc, (const int32_t *)val);
2420 }
2421 
2422 static inline void
vn_decode_VkImageType(struct vn_cs_decoder * dec,VkImageType * val)2423 vn_decode_VkImageType(struct vn_cs_decoder *dec, VkImageType *val)
2424 {
2425     vn_decode_int32_t(dec, (int32_t *)val);
2426 }
2427 
2428 /* enum VkImageViewType */
2429 
2430 static inline size_t
vn_sizeof_VkImageViewType(const VkImageViewType * val)2431 vn_sizeof_VkImageViewType(const VkImageViewType *val)
2432 {
2433     assert(sizeof(*val) == sizeof(int32_t));
2434     return vn_sizeof_int32_t((const int32_t *)val);
2435 }
2436 
2437 static inline void
vn_encode_VkImageViewType(struct vn_cs_encoder * enc,const VkImageViewType * val)2438 vn_encode_VkImageViewType(struct vn_cs_encoder *enc, const VkImageViewType *val)
2439 {
2440     vn_encode_int32_t(enc, (const int32_t *)val);
2441 }
2442 
2443 static inline void
vn_decode_VkImageViewType(struct vn_cs_decoder * dec,VkImageViewType * val)2444 vn_decode_VkImageViewType(struct vn_cs_decoder *dec, VkImageViewType *val)
2445 {
2446     vn_decode_int32_t(dec, (int32_t *)val);
2447 }
2448 
2449 /* enum VkSharingMode */
2450 
2451 static inline size_t
vn_sizeof_VkSharingMode(const VkSharingMode * val)2452 vn_sizeof_VkSharingMode(const VkSharingMode *val)
2453 {
2454     assert(sizeof(*val) == sizeof(int32_t));
2455     return vn_sizeof_int32_t((const int32_t *)val);
2456 }
2457 
2458 static inline void
vn_encode_VkSharingMode(struct vn_cs_encoder * enc,const VkSharingMode * val)2459 vn_encode_VkSharingMode(struct vn_cs_encoder *enc, const VkSharingMode *val)
2460 {
2461     vn_encode_int32_t(enc, (const int32_t *)val);
2462 }
2463 
2464 static inline void
vn_decode_VkSharingMode(struct vn_cs_decoder * dec,VkSharingMode * val)2465 vn_decode_VkSharingMode(struct vn_cs_decoder *dec, VkSharingMode *val)
2466 {
2467     vn_decode_int32_t(dec, (int32_t *)val);
2468 }
2469 
2470 /* enum VkIndexType */
2471 
2472 static inline size_t
vn_sizeof_VkIndexType(const VkIndexType * val)2473 vn_sizeof_VkIndexType(const VkIndexType *val)
2474 {
2475     assert(sizeof(*val) == sizeof(int32_t));
2476     return vn_sizeof_int32_t((const int32_t *)val);
2477 }
2478 
2479 static inline void
vn_encode_VkIndexType(struct vn_cs_encoder * enc,const VkIndexType * val)2480 vn_encode_VkIndexType(struct vn_cs_encoder *enc, const VkIndexType *val)
2481 {
2482     vn_encode_int32_t(enc, (const int32_t *)val);
2483 }
2484 
2485 static inline void
vn_decode_VkIndexType(struct vn_cs_decoder * dec,VkIndexType * val)2486 vn_decode_VkIndexType(struct vn_cs_decoder *dec, VkIndexType *val)
2487 {
2488     vn_decode_int32_t(dec, (int32_t *)val);
2489 }
2490 
2491 static inline size_t
vn_sizeof_VkIndexType_array(const VkIndexType * val,uint32_t count)2492 vn_sizeof_VkIndexType_array(const VkIndexType *val, uint32_t count)
2493 {
2494     return vn_sizeof_int32_t_array((const int32_t *)val, count);
2495 }
2496 
2497 static inline void
vn_encode_VkIndexType_array(struct vn_cs_encoder * enc,const VkIndexType * val,uint32_t count)2498 vn_encode_VkIndexType_array(struct vn_cs_encoder *enc, const VkIndexType *val, uint32_t count)
2499 {
2500     vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2501 }
2502 
2503 static inline void
vn_decode_VkIndexType_array(struct vn_cs_decoder * dec,VkIndexType * val,uint32_t count)2504 vn_decode_VkIndexType_array(struct vn_cs_decoder *dec, VkIndexType *val, uint32_t count)
2505 {
2506     vn_decode_int32_t_array(dec, (int32_t *)val, count);
2507 }
2508 
2509 /* enum VkLogicOp */
2510 
2511 static inline size_t
vn_sizeof_VkLogicOp(const VkLogicOp * val)2512 vn_sizeof_VkLogicOp(const VkLogicOp *val)
2513 {
2514     assert(sizeof(*val) == sizeof(int32_t));
2515     return vn_sizeof_int32_t((const int32_t *)val);
2516 }
2517 
2518 static inline void
vn_encode_VkLogicOp(struct vn_cs_encoder * enc,const VkLogicOp * val)2519 vn_encode_VkLogicOp(struct vn_cs_encoder *enc, const VkLogicOp *val)
2520 {
2521     vn_encode_int32_t(enc, (const int32_t *)val);
2522 }
2523 
2524 static inline void
vn_decode_VkLogicOp(struct vn_cs_decoder * dec,VkLogicOp * val)2525 vn_decode_VkLogicOp(struct vn_cs_decoder *dec, VkLogicOp *val)
2526 {
2527     vn_decode_int32_t(dec, (int32_t *)val);
2528 }
2529 
2530 /* enum VkPhysicalDeviceType */
2531 
2532 static inline size_t
vn_sizeof_VkPhysicalDeviceType(const VkPhysicalDeviceType * val)2533 vn_sizeof_VkPhysicalDeviceType(const VkPhysicalDeviceType *val)
2534 {
2535     assert(sizeof(*val) == sizeof(int32_t));
2536     return vn_sizeof_int32_t((const int32_t *)val);
2537 }
2538 
2539 static inline void
vn_encode_VkPhysicalDeviceType(struct vn_cs_encoder * enc,const VkPhysicalDeviceType * val)2540 vn_encode_VkPhysicalDeviceType(struct vn_cs_encoder *enc, const VkPhysicalDeviceType *val)
2541 {
2542     vn_encode_int32_t(enc, (const int32_t *)val);
2543 }
2544 
2545 static inline void
vn_decode_VkPhysicalDeviceType(struct vn_cs_decoder * dec,VkPhysicalDeviceType * val)2546 vn_decode_VkPhysicalDeviceType(struct vn_cs_decoder *dec, VkPhysicalDeviceType *val)
2547 {
2548     vn_decode_int32_t(dec, (int32_t *)val);
2549 }
2550 
2551 /* enum VkPipelineBindPoint */
2552 
2553 static inline size_t
vn_sizeof_VkPipelineBindPoint(const VkPipelineBindPoint * val)2554 vn_sizeof_VkPipelineBindPoint(const VkPipelineBindPoint *val)
2555 {
2556     assert(sizeof(*val) == sizeof(int32_t));
2557     return vn_sizeof_int32_t((const int32_t *)val);
2558 }
2559 
2560 static inline void
vn_encode_VkPipelineBindPoint(struct vn_cs_encoder * enc,const VkPipelineBindPoint * val)2561 vn_encode_VkPipelineBindPoint(struct vn_cs_encoder *enc, const VkPipelineBindPoint *val)
2562 {
2563     vn_encode_int32_t(enc, (const int32_t *)val);
2564 }
2565 
2566 static inline void
vn_decode_VkPipelineBindPoint(struct vn_cs_decoder * dec,VkPipelineBindPoint * val)2567 vn_decode_VkPipelineBindPoint(struct vn_cs_decoder *dec, VkPipelineBindPoint *val)
2568 {
2569     vn_decode_int32_t(dec, (int32_t *)val);
2570 }
2571 
2572 /* enum VkPrimitiveTopology */
2573 
2574 static inline size_t
vn_sizeof_VkPrimitiveTopology(const VkPrimitiveTopology * val)2575 vn_sizeof_VkPrimitiveTopology(const VkPrimitiveTopology *val)
2576 {
2577     assert(sizeof(*val) == sizeof(int32_t));
2578     return vn_sizeof_int32_t((const int32_t *)val);
2579 }
2580 
2581 static inline void
vn_encode_VkPrimitiveTopology(struct vn_cs_encoder * enc,const VkPrimitiveTopology * val)2582 vn_encode_VkPrimitiveTopology(struct vn_cs_encoder *enc, const VkPrimitiveTopology *val)
2583 {
2584     vn_encode_int32_t(enc, (const int32_t *)val);
2585 }
2586 
2587 static inline void
vn_decode_VkPrimitiveTopology(struct vn_cs_decoder * dec,VkPrimitiveTopology * val)2588 vn_decode_VkPrimitiveTopology(struct vn_cs_decoder *dec, VkPrimitiveTopology *val)
2589 {
2590     vn_decode_int32_t(dec, (int32_t *)val);
2591 }
2592 
2593 /* enum VkQueryType */
2594 
2595 static inline size_t
vn_sizeof_VkQueryType(const VkQueryType * val)2596 vn_sizeof_VkQueryType(const VkQueryType *val)
2597 {
2598     assert(sizeof(*val) == sizeof(int32_t));
2599     return vn_sizeof_int32_t((const int32_t *)val);
2600 }
2601 
2602 static inline void
vn_encode_VkQueryType(struct vn_cs_encoder * enc,const VkQueryType * val)2603 vn_encode_VkQueryType(struct vn_cs_encoder *enc, const VkQueryType *val)
2604 {
2605     vn_encode_int32_t(enc, (const int32_t *)val);
2606 }
2607 
2608 static inline void
vn_decode_VkQueryType(struct vn_cs_decoder * dec,VkQueryType * val)2609 vn_decode_VkQueryType(struct vn_cs_decoder *dec, VkQueryType *val)
2610 {
2611     vn_decode_int32_t(dec, (int32_t *)val);
2612 }
2613 
2614 /* enum VkSubpassContents */
2615 
2616 static inline size_t
vn_sizeof_VkSubpassContents(const VkSubpassContents * val)2617 vn_sizeof_VkSubpassContents(const VkSubpassContents *val)
2618 {
2619     assert(sizeof(*val) == sizeof(int32_t));
2620     return vn_sizeof_int32_t((const int32_t *)val);
2621 }
2622 
2623 static inline void
vn_encode_VkSubpassContents(struct vn_cs_encoder * enc,const VkSubpassContents * val)2624 vn_encode_VkSubpassContents(struct vn_cs_encoder *enc, const VkSubpassContents *val)
2625 {
2626     vn_encode_int32_t(enc, (const int32_t *)val);
2627 }
2628 
2629 static inline void
vn_decode_VkSubpassContents(struct vn_cs_decoder * dec,VkSubpassContents * val)2630 vn_decode_VkSubpassContents(struct vn_cs_decoder *dec, VkSubpassContents *val)
2631 {
2632     vn_decode_int32_t(dec, (int32_t *)val);
2633 }
2634 
2635 /* enum VkResult */
2636 
2637 static inline size_t
vn_sizeof_VkResult(const VkResult * val)2638 vn_sizeof_VkResult(const VkResult *val)
2639 {
2640     assert(sizeof(*val) == sizeof(int32_t));
2641     return vn_sizeof_int32_t((const int32_t *)val);
2642 }
2643 
2644 static inline void
vn_encode_VkResult(struct vn_cs_encoder * enc,const VkResult * val)2645 vn_encode_VkResult(struct vn_cs_encoder *enc, const VkResult *val)
2646 {
2647     vn_encode_int32_t(enc, (const int32_t *)val);
2648 }
2649 
2650 static inline void
vn_decode_VkResult(struct vn_cs_decoder * dec,VkResult * val)2651 vn_decode_VkResult(struct vn_cs_decoder *dec, VkResult *val)
2652 {
2653     vn_decode_int32_t(dec, (int32_t *)val);
2654 }
2655 
2656 static inline size_t
vn_sizeof_VkResult_array(const VkResult * val,uint32_t count)2657 vn_sizeof_VkResult_array(const VkResult *val, uint32_t count)
2658 {
2659     return vn_sizeof_int32_t_array((const int32_t *)val, count);
2660 }
2661 
2662 static inline void
vn_encode_VkResult_array(struct vn_cs_encoder * enc,const VkResult * val,uint32_t count)2663 vn_encode_VkResult_array(struct vn_cs_encoder *enc, const VkResult *val, uint32_t count)
2664 {
2665     vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2666 }
2667 
2668 static inline void
vn_decode_VkResult_array(struct vn_cs_decoder * dec,VkResult * val,uint32_t count)2669 vn_decode_VkResult_array(struct vn_cs_decoder *dec, VkResult *val, uint32_t count)
2670 {
2671     vn_decode_int32_t_array(dec, (int32_t *)val, count);
2672 }
2673 
2674 /* enum VkStencilOp */
2675 
2676 static inline size_t
vn_sizeof_VkStencilOp(const VkStencilOp * val)2677 vn_sizeof_VkStencilOp(const VkStencilOp *val)
2678 {
2679     assert(sizeof(*val) == sizeof(int32_t));
2680     return vn_sizeof_int32_t((const int32_t *)val);
2681 }
2682 
2683 static inline void
vn_encode_VkStencilOp(struct vn_cs_encoder * enc,const VkStencilOp * val)2684 vn_encode_VkStencilOp(struct vn_cs_encoder *enc, const VkStencilOp *val)
2685 {
2686     vn_encode_int32_t(enc, (const int32_t *)val);
2687 }
2688 
2689 static inline void
vn_decode_VkStencilOp(struct vn_cs_decoder * dec,VkStencilOp * val)2690 vn_decode_VkStencilOp(struct vn_cs_decoder *dec, VkStencilOp *val)
2691 {
2692     vn_decode_int32_t(dec, (int32_t *)val);
2693 }
2694 
2695 /* enum VkSystemAllocationScope */
2696 
2697 static inline size_t
vn_sizeof_VkSystemAllocationScope(const VkSystemAllocationScope * val)2698 vn_sizeof_VkSystemAllocationScope(const VkSystemAllocationScope *val)
2699 {
2700     assert(sizeof(*val) == sizeof(int32_t));
2701     return vn_sizeof_int32_t((const int32_t *)val);
2702 }
2703 
2704 static inline void
vn_encode_VkSystemAllocationScope(struct vn_cs_encoder * enc,const VkSystemAllocationScope * val)2705 vn_encode_VkSystemAllocationScope(struct vn_cs_encoder *enc, const VkSystemAllocationScope *val)
2706 {
2707     vn_encode_int32_t(enc, (const int32_t *)val);
2708 }
2709 
2710 static inline void
vn_decode_VkSystemAllocationScope(struct vn_cs_decoder * dec,VkSystemAllocationScope * val)2711 vn_decode_VkSystemAllocationScope(struct vn_cs_decoder *dec, VkSystemAllocationScope *val)
2712 {
2713     vn_decode_int32_t(dec, (int32_t *)val);
2714 }
2715 
2716 /* enum VkInternalAllocationType */
2717 
2718 static inline size_t
vn_sizeof_VkInternalAllocationType(const VkInternalAllocationType * val)2719 vn_sizeof_VkInternalAllocationType(const VkInternalAllocationType *val)
2720 {
2721     assert(sizeof(*val) == sizeof(int32_t));
2722     return vn_sizeof_int32_t((const int32_t *)val);
2723 }
2724 
2725 static inline void
vn_encode_VkInternalAllocationType(struct vn_cs_encoder * enc,const VkInternalAllocationType * val)2726 vn_encode_VkInternalAllocationType(struct vn_cs_encoder *enc, const VkInternalAllocationType *val)
2727 {
2728     vn_encode_int32_t(enc, (const int32_t *)val);
2729 }
2730 
2731 static inline void
vn_decode_VkInternalAllocationType(struct vn_cs_decoder * dec,VkInternalAllocationType * val)2732 vn_decode_VkInternalAllocationType(struct vn_cs_decoder *dec, VkInternalAllocationType *val)
2733 {
2734     vn_decode_int32_t(dec, (int32_t *)val);
2735 }
2736 
2737 /* enum VkSamplerAddressMode */
2738 
2739 static inline size_t
vn_sizeof_VkSamplerAddressMode(const VkSamplerAddressMode * val)2740 vn_sizeof_VkSamplerAddressMode(const VkSamplerAddressMode *val)
2741 {
2742     assert(sizeof(*val) == sizeof(int32_t));
2743     return vn_sizeof_int32_t((const int32_t *)val);
2744 }
2745 
2746 static inline void
vn_encode_VkSamplerAddressMode(struct vn_cs_encoder * enc,const VkSamplerAddressMode * val)2747 vn_encode_VkSamplerAddressMode(struct vn_cs_encoder *enc, const VkSamplerAddressMode *val)
2748 {
2749     vn_encode_int32_t(enc, (const int32_t *)val);
2750 }
2751 
2752 static inline void
vn_decode_VkSamplerAddressMode(struct vn_cs_decoder * dec,VkSamplerAddressMode * val)2753 vn_decode_VkSamplerAddressMode(struct vn_cs_decoder *dec, VkSamplerAddressMode *val)
2754 {
2755     vn_decode_int32_t(dec, (int32_t *)val);
2756 }
2757 
2758 /* enum VkFilter */
2759 
2760 static inline size_t
vn_sizeof_VkFilter(const VkFilter * val)2761 vn_sizeof_VkFilter(const VkFilter *val)
2762 {
2763     assert(sizeof(*val) == sizeof(int32_t));
2764     return vn_sizeof_int32_t((const int32_t *)val);
2765 }
2766 
2767 static inline void
vn_encode_VkFilter(struct vn_cs_encoder * enc,const VkFilter * val)2768 vn_encode_VkFilter(struct vn_cs_encoder *enc, const VkFilter *val)
2769 {
2770     vn_encode_int32_t(enc, (const int32_t *)val);
2771 }
2772 
2773 static inline void
vn_decode_VkFilter(struct vn_cs_decoder * dec,VkFilter * val)2774 vn_decode_VkFilter(struct vn_cs_decoder *dec, VkFilter *val)
2775 {
2776     vn_decode_int32_t(dec, (int32_t *)val);
2777 }
2778 
2779 /* enum VkSamplerMipmapMode */
2780 
2781 static inline size_t
vn_sizeof_VkSamplerMipmapMode(const VkSamplerMipmapMode * val)2782 vn_sizeof_VkSamplerMipmapMode(const VkSamplerMipmapMode *val)
2783 {
2784     assert(sizeof(*val) == sizeof(int32_t));
2785     return vn_sizeof_int32_t((const int32_t *)val);
2786 }
2787 
2788 static inline void
vn_encode_VkSamplerMipmapMode(struct vn_cs_encoder * enc,const VkSamplerMipmapMode * val)2789 vn_encode_VkSamplerMipmapMode(struct vn_cs_encoder *enc, const VkSamplerMipmapMode *val)
2790 {
2791     vn_encode_int32_t(enc, (const int32_t *)val);
2792 }
2793 
2794 static inline void
vn_decode_VkSamplerMipmapMode(struct vn_cs_decoder * dec,VkSamplerMipmapMode * val)2795 vn_decode_VkSamplerMipmapMode(struct vn_cs_decoder *dec, VkSamplerMipmapMode *val)
2796 {
2797     vn_decode_int32_t(dec, (int32_t *)val);
2798 }
2799 
2800 /* enum VkVertexInputRate */
2801 
2802 static inline size_t
vn_sizeof_VkVertexInputRate(const VkVertexInputRate * val)2803 vn_sizeof_VkVertexInputRate(const VkVertexInputRate *val)
2804 {
2805     assert(sizeof(*val) == sizeof(int32_t));
2806     return vn_sizeof_int32_t((const int32_t *)val);
2807 }
2808 
2809 static inline void
vn_encode_VkVertexInputRate(struct vn_cs_encoder * enc,const VkVertexInputRate * val)2810 vn_encode_VkVertexInputRate(struct vn_cs_encoder *enc, const VkVertexInputRate *val)
2811 {
2812     vn_encode_int32_t(enc, (const int32_t *)val);
2813 }
2814 
2815 static inline void
vn_decode_VkVertexInputRate(struct vn_cs_decoder * dec,VkVertexInputRate * val)2816 vn_decode_VkVertexInputRate(struct vn_cs_decoder *dec, VkVertexInputRate *val)
2817 {
2818     vn_decode_int32_t(dec, (int32_t *)val);
2819 }
2820 
2821 /* enum VkObjectType */
2822 
2823 static inline size_t
vn_sizeof_VkObjectType(const VkObjectType * val)2824 vn_sizeof_VkObjectType(const VkObjectType *val)
2825 {
2826     assert(sizeof(*val) == sizeof(int32_t));
2827     return vn_sizeof_int32_t((const int32_t *)val);
2828 }
2829 
2830 static inline void
vn_encode_VkObjectType(struct vn_cs_encoder * enc,const VkObjectType * val)2831 vn_encode_VkObjectType(struct vn_cs_encoder *enc, const VkObjectType *val)
2832 {
2833     vn_encode_int32_t(enc, (const int32_t *)val);
2834 }
2835 
2836 static inline void
vn_decode_VkObjectType(struct vn_cs_decoder * dec,VkObjectType * val)2837 vn_decode_VkObjectType(struct vn_cs_decoder *dec, VkObjectType *val)
2838 {
2839     vn_decode_int32_t(dec, (int32_t *)val);
2840 }
2841 
2842 /* enum VkDescriptorUpdateTemplateType */
2843 
2844 static inline size_t
vn_sizeof_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType * val)2845 vn_sizeof_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType *val)
2846 {
2847     assert(sizeof(*val) == sizeof(int32_t));
2848     return vn_sizeof_int32_t((const int32_t *)val);
2849 }
2850 
2851 static inline void
vn_encode_VkDescriptorUpdateTemplateType(struct vn_cs_encoder * enc,const VkDescriptorUpdateTemplateType * val)2852 vn_encode_VkDescriptorUpdateTemplateType(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateType *val)
2853 {
2854     vn_encode_int32_t(enc, (const int32_t *)val);
2855 }
2856 
2857 static inline void
vn_decode_VkDescriptorUpdateTemplateType(struct vn_cs_decoder * dec,VkDescriptorUpdateTemplateType * val)2858 vn_decode_VkDescriptorUpdateTemplateType(struct vn_cs_decoder *dec, VkDescriptorUpdateTemplateType *val)
2859 {
2860     vn_decode_int32_t(dec, (int32_t *)val);
2861 }
2862 
2863 /* enum VkPointClippingBehavior */
2864 
2865 static inline size_t
vn_sizeof_VkPointClippingBehavior(const VkPointClippingBehavior * val)2866 vn_sizeof_VkPointClippingBehavior(const VkPointClippingBehavior *val)
2867 {
2868     assert(sizeof(*val) == sizeof(int32_t));
2869     return vn_sizeof_int32_t((const int32_t *)val);
2870 }
2871 
2872 static inline void
vn_encode_VkPointClippingBehavior(struct vn_cs_encoder * enc,const VkPointClippingBehavior * val)2873 vn_encode_VkPointClippingBehavior(struct vn_cs_encoder *enc, const VkPointClippingBehavior *val)
2874 {
2875     vn_encode_int32_t(enc, (const int32_t *)val);
2876 }
2877 
2878 static inline void
vn_decode_VkPointClippingBehavior(struct vn_cs_decoder * dec,VkPointClippingBehavior * val)2879 vn_decode_VkPointClippingBehavior(struct vn_cs_decoder *dec, VkPointClippingBehavior *val)
2880 {
2881     vn_decode_int32_t(dec, (int32_t *)val);
2882 }
2883 
2884 /* enum VkTimeDomainEXT */
2885 
2886 static inline size_t
vn_sizeof_VkTimeDomainEXT(const VkTimeDomainEXT * val)2887 vn_sizeof_VkTimeDomainEXT(const VkTimeDomainEXT *val)
2888 {
2889     assert(sizeof(*val) == sizeof(int32_t));
2890     return vn_sizeof_int32_t((const int32_t *)val);
2891 }
2892 
2893 static inline void
vn_encode_VkTimeDomainEXT(struct vn_cs_encoder * enc,const VkTimeDomainEXT * val)2894 vn_encode_VkTimeDomainEXT(struct vn_cs_encoder *enc, const VkTimeDomainEXT *val)
2895 {
2896     vn_encode_int32_t(enc, (const int32_t *)val);
2897 }
2898 
2899 static inline void
vn_decode_VkTimeDomainEXT(struct vn_cs_decoder * dec,VkTimeDomainEXT * val)2900 vn_decode_VkTimeDomainEXT(struct vn_cs_decoder *dec, VkTimeDomainEXT *val)
2901 {
2902     vn_decode_int32_t(dec, (int32_t *)val);
2903 }
2904 
2905 static inline size_t
vn_sizeof_VkTimeDomainEXT_array(const VkTimeDomainEXT * val,uint32_t count)2906 vn_sizeof_VkTimeDomainEXT_array(const VkTimeDomainEXT *val, uint32_t count)
2907 {
2908     return vn_sizeof_int32_t_array((const int32_t *)val, count);
2909 }
2910 
2911 static inline void
vn_encode_VkTimeDomainEXT_array(struct vn_cs_encoder * enc,const VkTimeDomainEXT * val,uint32_t count)2912 vn_encode_VkTimeDomainEXT_array(struct vn_cs_encoder *enc, const VkTimeDomainEXT *val, uint32_t count)
2913 {
2914     vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2915 }
2916 
2917 static inline void
vn_decode_VkTimeDomainEXT_array(struct vn_cs_decoder * dec,VkTimeDomainEXT * val,uint32_t count)2918 vn_decode_VkTimeDomainEXT_array(struct vn_cs_decoder *dec, VkTimeDomainEXT *val, uint32_t count)
2919 {
2920     vn_decode_int32_t_array(dec, (int32_t *)val, count);
2921 }
2922 
2923 /* enum VkConservativeRasterizationModeEXT */
2924 
2925 static inline size_t
vn_sizeof_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT * val)2926 vn_sizeof_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT *val)
2927 {
2928     assert(sizeof(*val) == sizeof(int32_t));
2929     return vn_sizeof_int32_t((const int32_t *)val);
2930 }
2931 
2932 static inline void
vn_encode_VkConservativeRasterizationModeEXT(struct vn_cs_encoder * enc,const VkConservativeRasterizationModeEXT * val)2933 vn_encode_VkConservativeRasterizationModeEXT(struct vn_cs_encoder *enc, const VkConservativeRasterizationModeEXT *val)
2934 {
2935     vn_encode_int32_t(enc, (const int32_t *)val);
2936 }
2937 
2938 static inline void
vn_decode_VkConservativeRasterizationModeEXT(struct vn_cs_decoder * dec,VkConservativeRasterizationModeEXT * val)2939 vn_decode_VkConservativeRasterizationModeEXT(struct vn_cs_decoder *dec, VkConservativeRasterizationModeEXT *val)
2940 {
2941     vn_decode_int32_t(dec, (int32_t *)val);
2942 }
2943 
2944 /* enum VkSemaphoreType */
2945 
2946 static inline size_t
vn_sizeof_VkSemaphoreType(const VkSemaphoreType * val)2947 vn_sizeof_VkSemaphoreType(const VkSemaphoreType *val)
2948 {
2949     assert(sizeof(*val) == sizeof(int32_t));
2950     return vn_sizeof_int32_t((const int32_t *)val);
2951 }
2952 
2953 static inline void
vn_encode_VkSemaphoreType(struct vn_cs_encoder * enc,const VkSemaphoreType * val)2954 vn_encode_VkSemaphoreType(struct vn_cs_encoder *enc, const VkSemaphoreType *val)
2955 {
2956     vn_encode_int32_t(enc, (const int32_t *)val);
2957 }
2958 
2959 static inline void
vn_decode_VkSemaphoreType(struct vn_cs_decoder * dec,VkSemaphoreType * val)2960 vn_decode_VkSemaphoreType(struct vn_cs_decoder *dec, VkSemaphoreType *val)
2961 {
2962     vn_decode_int32_t(dec, (int32_t *)val);
2963 }
2964 
2965 /* enum VkLineRasterizationModeEXT */
2966 
2967 static inline size_t
vn_sizeof_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT * val)2968 vn_sizeof_VkLineRasterizationModeEXT(const VkLineRasterizationModeEXT *val)
2969 {
2970     assert(sizeof(*val) == sizeof(int32_t));
2971     return vn_sizeof_int32_t((const int32_t *)val);
2972 }
2973 
2974 static inline void
vn_encode_VkLineRasterizationModeEXT(struct vn_cs_encoder * enc,const VkLineRasterizationModeEXT * val)2975 vn_encode_VkLineRasterizationModeEXT(struct vn_cs_encoder *enc, const VkLineRasterizationModeEXT *val)
2976 {
2977     vn_encode_int32_t(enc, (const int32_t *)val);
2978 }
2979 
2980 static inline void
vn_decode_VkLineRasterizationModeEXT(struct vn_cs_decoder * dec,VkLineRasterizationModeEXT * val)2981 vn_decode_VkLineRasterizationModeEXT(struct vn_cs_decoder *dec, VkLineRasterizationModeEXT *val)
2982 {
2983     vn_decode_int32_t(dec, (int32_t *)val);
2984 }
2985 
2986 /* enum VkProvokingVertexModeEXT */
2987 
2988 static inline size_t
vn_sizeof_VkProvokingVertexModeEXT(const VkProvokingVertexModeEXT * val)2989 vn_sizeof_VkProvokingVertexModeEXT(const VkProvokingVertexModeEXT *val)
2990 {
2991     assert(sizeof(*val) == sizeof(int32_t));
2992     return vn_sizeof_int32_t((const int32_t *)val);
2993 }
2994 
2995 static inline void
vn_encode_VkProvokingVertexModeEXT(struct vn_cs_encoder * enc,const VkProvokingVertexModeEXT * val)2996 vn_encode_VkProvokingVertexModeEXT(struct vn_cs_encoder *enc, const VkProvokingVertexModeEXT *val)
2997 {
2998     vn_encode_int32_t(enc, (const int32_t *)val);
2999 }
3000 
3001 static inline void
vn_decode_VkProvokingVertexModeEXT(struct vn_cs_decoder * dec,VkProvokingVertexModeEXT * val)3002 vn_decode_VkProvokingVertexModeEXT(struct vn_cs_decoder *dec, VkProvokingVertexModeEXT *val)
3003 {
3004     vn_decode_int32_t(dec, (int32_t *)val);
3005 }
3006 
3007 /* enum VkTessellationDomainOrigin */
3008 
3009 static inline size_t
vn_sizeof_VkTessellationDomainOrigin(const VkTessellationDomainOrigin * val)3010 vn_sizeof_VkTessellationDomainOrigin(const VkTessellationDomainOrigin *val)
3011 {
3012     assert(sizeof(*val) == sizeof(int32_t));
3013     return vn_sizeof_int32_t((const int32_t *)val);
3014 }
3015 
3016 static inline void
vn_encode_VkTessellationDomainOrigin(struct vn_cs_encoder * enc,const VkTessellationDomainOrigin * val)3017 vn_encode_VkTessellationDomainOrigin(struct vn_cs_encoder *enc, const VkTessellationDomainOrigin *val)
3018 {
3019     vn_encode_int32_t(enc, (const int32_t *)val);
3020 }
3021 
3022 static inline void
vn_decode_VkTessellationDomainOrigin(struct vn_cs_decoder * dec,VkTessellationDomainOrigin * val)3023 vn_decode_VkTessellationDomainOrigin(struct vn_cs_decoder *dec, VkTessellationDomainOrigin *val)
3024 {
3025     vn_decode_int32_t(dec, (int32_t *)val);
3026 }
3027 
3028 /* enum VkSamplerYcbcrModelConversion */
3029 
3030 static inline size_t
vn_sizeof_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion * val)3031 vn_sizeof_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion *val)
3032 {
3033     assert(sizeof(*val) == sizeof(int32_t));
3034     return vn_sizeof_int32_t((const int32_t *)val);
3035 }
3036 
3037 static inline void
vn_encode_VkSamplerYcbcrModelConversion(struct vn_cs_encoder * enc,const VkSamplerYcbcrModelConversion * val)3038 vn_encode_VkSamplerYcbcrModelConversion(struct vn_cs_encoder *enc, const VkSamplerYcbcrModelConversion *val)
3039 {
3040     vn_encode_int32_t(enc, (const int32_t *)val);
3041 }
3042 
3043 static inline void
vn_decode_VkSamplerYcbcrModelConversion(struct vn_cs_decoder * dec,VkSamplerYcbcrModelConversion * val)3044 vn_decode_VkSamplerYcbcrModelConversion(struct vn_cs_decoder *dec, VkSamplerYcbcrModelConversion *val)
3045 {
3046     vn_decode_int32_t(dec, (int32_t *)val);
3047 }
3048 
3049 /* enum VkSamplerYcbcrRange */
3050 
3051 static inline size_t
vn_sizeof_VkSamplerYcbcrRange(const VkSamplerYcbcrRange * val)3052 vn_sizeof_VkSamplerYcbcrRange(const VkSamplerYcbcrRange *val)
3053 {
3054     assert(sizeof(*val) == sizeof(int32_t));
3055     return vn_sizeof_int32_t((const int32_t *)val);
3056 }
3057 
3058 static inline void
vn_encode_VkSamplerYcbcrRange(struct vn_cs_encoder * enc,const VkSamplerYcbcrRange * val)3059 vn_encode_VkSamplerYcbcrRange(struct vn_cs_encoder *enc, const VkSamplerYcbcrRange *val)
3060 {
3061     vn_encode_int32_t(enc, (const int32_t *)val);
3062 }
3063 
3064 static inline void
vn_decode_VkSamplerYcbcrRange(struct vn_cs_decoder * dec,VkSamplerYcbcrRange * val)3065 vn_decode_VkSamplerYcbcrRange(struct vn_cs_decoder *dec, VkSamplerYcbcrRange *val)
3066 {
3067     vn_decode_int32_t(dec, (int32_t *)val);
3068 }
3069 
3070 /* enum VkChromaLocation */
3071 
3072 static inline size_t
vn_sizeof_VkChromaLocation(const VkChromaLocation * val)3073 vn_sizeof_VkChromaLocation(const VkChromaLocation *val)
3074 {
3075     assert(sizeof(*val) == sizeof(int32_t));
3076     return vn_sizeof_int32_t((const int32_t *)val);
3077 }
3078 
3079 static inline void
vn_encode_VkChromaLocation(struct vn_cs_encoder * enc,const VkChromaLocation * val)3080 vn_encode_VkChromaLocation(struct vn_cs_encoder *enc, const VkChromaLocation *val)
3081 {
3082     vn_encode_int32_t(enc, (const int32_t *)val);
3083 }
3084 
3085 static inline void
vn_decode_VkChromaLocation(struct vn_cs_decoder * dec,VkChromaLocation * val)3086 vn_decode_VkChromaLocation(struct vn_cs_decoder *dec, VkChromaLocation *val)
3087 {
3088     vn_decode_int32_t(dec, (int32_t *)val);
3089 }
3090 
3091 /* enum VkSamplerReductionMode */
3092 
3093 static inline size_t
vn_sizeof_VkSamplerReductionMode(const VkSamplerReductionMode * val)3094 vn_sizeof_VkSamplerReductionMode(const VkSamplerReductionMode *val)
3095 {
3096     assert(sizeof(*val) == sizeof(int32_t));
3097     return vn_sizeof_int32_t((const int32_t *)val);
3098 }
3099 
3100 static inline void
vn_encode_VkSamplerReductionMode(struct vn_cs_encoder * enc,const VkSamplerReductionMode * val)3101 vn_encode_VkSamplerReductionMode(struct vn_cs_encoder *enc, const VkSamplerReductionMode *val)
3102 {
3103     vn_encode_int32_t(enc, (const int32_t *)val);
3104 }
3105 
3106 static inline void
vn_decode_VkSamplerReductionMode(struct vn_cs_decoder * dec,VkSamplerReductionMode * val)3107 vn_decode_VkSamplerReductionMode(struct vn_cs_decoder *dec, VkSamplerReductionMode *val)
3108 {
3109     vn_decode_int32_t(dec, (int32_t *)val);
3110 }
3111 
3112 /* enum VkShaderFloatControlsIndependence */
3113 
3114 static inline size_t
vn_sizeof_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence * val)3115 vn_sizeof_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence *val)
3116 {
3117     assert(sizeof(*val) == sizeof(int32_t));
3118     return vn_sizeof_int32_t((const int32_t *)val);
3119 }
3120 
3121 static inline void
vn_encode_VkShaderFloatControlsIndependence(struct vn_cs_encoder * enc,const VkShaderFloatControlsIndependence * val)3122 vn_encode_VkShaderFloatControlsIndependence(struct vn_cs_encoder *enc, const VkShaderFloatControlsIndependence *val)
3123 {
3124     vn_encode_int32_t(enc, (const int32_t *)val);
3125 }
3126 
3127 static inline void
vn_decode_VkShaderFloatControlsIndependence(struct vn_cs_decoder * dec,VkShaderFloatControlsIndependence * val)3128 vn_decode_VkShaderFloatControlsIndependence(struct vn_cs_decoder *dec, VkShaderFloatControlsIndependence *val)
3129 {
3130     vn_decode_int32_t(dec, (int32_t *)val);
3131 }
3132 
3133 /* enum VkVendorId */
3134 
3135 static inline size_t
vn_sizeof_VkVendorId(const VkVendorId * val)3136 vn_sizeof_VkVendorId(const VkVendorId *val)
3137 {
3138     assert(sizeof(*val) == sizeof(int32_t));
3139     return vn_sizeof_int32_t((const int32_t *)val);
3140 }
3141 
3142 static inline void
vn_encode_VkVendorId(struct vn_cs_encoder * enc,const VkVendorId * val)3143 vn_encode_VkVendorId(struct vn_cs_encoder *enc, const VkVendorId *val)
3144 {
3145     vn_encode_int32_t(enc, (const int32_t *)val);
3146 }
3147 
3148 static inline void
vn_decode_VkVendorId(struct vn_cs_decoder * dec,VkVendorId * val)3149 vn_decode_VkVendorId(struct vn_cs_decoder *dec, VkVendorId *val)
3150 {
3151     vn_decode_int32_t(dec, (int32_t *)val);
3152 }
3153 
3154 /* enum VkDriverId */
3155 
3156 static inline size_t
vn_sizeof_VkDriverId(const VkDriverId * val)3157 vn_sizeof_VkDriverId(const VkDriverId *val)
3158 {
3159     assert(sizeof(*val) == sizeof(int32_t));
3160     return vn_sizeof_int32_t((const int32_t *)val);
3161 }
3162 
3163 static inline void
vn_encode_VkDriverId(struct vn_cs_encoder * enc,const VkDriverId * val)3164 vn_encode_VkDriverId(struct vn_cs_encoder *enc, const VkDriverId *val)
3165 {
3166     vn_encode_int32_t(enc, (const int32_t *)val);
3167 }
3168 
3169 static inline void
vn_decode_VkDriverId(struct vn_cs_decoder * dec,VkDriverId * val)3170 vn_decode_VkDriverId(struct vn_cs_decoder *dec, VkDriverId *val)
3171 {
3172     vn_decode_int32_t(dec, (int32_t *)val);
3173 }
3174 
3175 /* enum VkCommandFlagBitsEXT */
3176 
3177 static inline size_t
vn_sizeof_VkCommandFlagBitsEXT(const VkCommandFlagBitsEXT * val)3178 vn_sizeof_VkCommandFlagBitsEXT(const VkCommandFlagBitsEXT *val)
3179 {
3180     assert(sizeof(*val) == sizeof(int32_t));
3181     return vn_sizeof_int32_t((const int32_t *)val);
3182 }
3183 
3184 static inline void
vn_encode_VkCommandFlagBitsEXT(struct vn_cs_encoder * enc,const VkCommandFlagBitsEXT * val)3185 vn_encode_VkCommandFlagBitsEXT(struct vn_cs_encoder *enc, const VkCommandFlagBitsEXT *val)
3186 {
3187     vn_encode_int32_t(enc, (const int32_t *)val);
3188 }
3189 
3190 static inline void
vn_decode_VkCommandFlagBitsEXT(struct vn_cs_decoder * dec,VkCommandFlagBitsEXT * val)3191 vn_decode_VkCommandFlagBitsEXT(struct vn_cs_decoder *dec, VkCommandFlagBitsEXT *val)
3192 {
3193     vn_decode_int32_t(dec, (int32_t *)val);
3194 }
3195 
3196 /* enum VkCommandTypeEXT */
3197 
3198 static inline size_t
vn_sizeof_VkCommandTypeEXT(const VkCommandTypeEXT * val)3199 vn_sizeof_VkCommandTypeEXT(const VkCommandTypeEXT *val)
3200 {
3201     assert(sizeof(*val) == sizeof(int32_t));
3202     return vn_sizeof_int32_t((const int32_t *)val);
3203 }
3204 
3205 static inline void
vn_encode_VkCommandTypeEXT(struct vn_cs_encoder * enc,const VkCommandTypeEXT * val)3206 vn_encode_VkCommandTypeEXT(struct vn_cs_encoder *enc, const VkCommandTypeEXT *val)
3207 {
3208     vn_encode_int32_t(enc, (const int32_t *)val);
3209 }
3210 
3211 static inline void
vn_decode_VkCommandTypeEXT(struct vn_cs_decoder * dec,VkCommandTypeEXT * val)3212 vn_decode_VkCommandTypeEXT(struct vn_cs_decoder *dec, VkCommandTypeEXT *val)
3213 {
3214     vn_decode_int32_t(dec, (int32_t *)val);
3215 }
3216 
3217 #endif /* VN_PROTOCOL_DRIVER_TYPES_H */
3218