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_defines.h"
12
13 /* uint64_t */
14
15 static inline size_t
vn_sizeof_uint64_t(const uint64_t * val)16 vn_sizeof_uint64_t(const uint64_t *val)
17 {
18 assert(sizeof(*val) == 8);
19 return 8;
20 }
21
22 static inline void
vn_encode_uint64_t(struct vn_cs_encoder * enc,const uint64_t * val)23 vn_encode_uint64_t(struct vn_cs_encoder *enc, const uint64_t *val)
24 {
25 vn_encode(enc, 8, val, sizeof(*val));
26 }
27
28 static inline void
vn_decode_uint64_t(struct vn_cs_decoder * dec,uint64_t * val)29 vn_decode_uint64_t(struct vn_cs_decoder *dec, uint64_t *val)
30 {
31 vn_decode(dec, 8, val, sizeof(*val));
32 }
33
34 static inline size_t
vn_sizeof_uint64_t_array(const uint64_t * val,uint32_t count)35 vn_sizeof_uint64_t_array(const uint64_t *val, uint32_t count)
36 {
37 assert(sizeof(*val) == 8);
38 const size_t size = sizeof(*val) * count;
39 assert(size >= count);
40 return size;
41 }
42
43 static inline void
vn_encode_uint64_t_array(struct vn_cs_encoder * enc,const uint64_t * val,uint32_t count)44 vn_encode_uint64_t_array(struct vn_cs_encoder *enc, const uint64_t *val, uint32_t count)
45 {
46 const size_t size = sizeof(*val) * count;
47 assert(size >= count);
48 vn_encode(enc, size, val, size);
49 }
50
51 static inline void
vn_decode_uint64_t_array(struct vn_cs_decoder * dec,uint64_t * val,uint32_t count)52 vn_decode_uint64_t_array(struct vn_cs_decoder *dec, uint64_t *val, uint32_t count)
53 {
54 const size_t size = sizeof(*val) * count;
55 assert(size >= count);
56 vn_decode(dec, size, val, size);
57 }
58
59 /* int32_t */
60
61 static inline size_t
vn_sizeof_int32_t(const int32_t * val)62 vn_sizeof_int32_t(const int32_t *val)
63 {
64 assert(sizeof(*val) == 4);
65 return 4;
66 }
67
68 static inline void
vn_encode_int32_t(struct vn_cs_encoder * enc,const int32_t * val)69 vn_encode_int32_t(struct vn_cs_encoder *enc, const int32_t *val)
70 {
71 vn_encode(enc, 4, val, sizeof(*val));
72 }
73
74 static inline void
vn_decode_int32_t(struct vn_cs_decoder * dec,int32_t * val)75 vn_decode_int32_t(struct vn_cs_decoder *dec, int32_t *val)
76 {
77 vn_decode(dec, 4, val, sizeof(*val));
78 }
79
80 static inline size_t
vn_sizeof_int32_t_array(const int32_t * val,uint32_t count)81 vn_sizeof_int32_t_array(const int32_t *val, uint32_t count)
82 {
83 assert(sizeof(*val) == 4);
84 const size_t size = sizeof(*val) * count;
85 assert(size >= count);
86 return size;
87 }
88
89 static inline void
vn_encode_int32_t_array(struct vn_cs_encoder * enc,const int32_t * val,uint32_t count)90 vn_encode_int32_t_array(struct vn_cs_encoder *enc, const int32_t *val, uint32_t count)
91 {
92 const size_t size = sizeof(*val) * count;
93 assert(size >= count);
94 vn_encode(enc, size, val, size);
95 }
96
97 static inline void
vn_decode_int32_t_array(struct vn_cs_decoder * dec,int32_t * val,uint32_t count)98 vn_decode_int32_t_array(struct vn_cs_decoder *dec, int32_t *val, uint32_t count)
99 {
100 const size_t size = sizeof(*val) * count;
101 assert(size >= count);
102 vn_decode(dec, size, val, size);
103 }
104
105 /* enum VkStructureType */
106
107 static inline size_t
vn_sizeof_VkStructureType(const VkStructureType * val)108 vn_sizeof_VkStructureType(const VkStructureType *val)
109 {
110 assert(sizeof(*val) == sizeof(int32_t));
111 return vn_sizeof_int32_t((const int32_t *)val);
112 }
113
114 static inline void
vn_encode_VkStructureType(struct vn_cs_encoder * enc,const VkStructureType * val)115 vn_encode_VkStructureType(struct vn_cs_encoder *enc, const VkStructureType *val)
116 {
117 vn_encode_int32_t(enc, (const int32_t *)val);
118 }
119
120 static inline void
vn_decode_VkStructureType(struct vn_cs_decoder * dec,VkStructureType * val)121 vn_decode_VkStructureType(struct vn_cs_decoder *dec, VkStructureType *val)
122 {
123 vn_decode_int32_t(dec, (int32_t *)val);
124 }
125
126 /* size_t */
127
128 static inline size_t
vn_sizeof_size_t(const size_t * val)129 vn_sizeof_size_t(const size_t *val)
130 {
131 return vn_sizeof_uint64_t(&(uint64_t){ *val });
132 }
133
134 static inline void
vn_encode_size_t(struct vn_cs_encoder * enc,const size_t * val)135 vn_encode_size_t(struct vn_cs_encoder *enc, const size_t *val)
136 {
137 const uint64_t tmp = *val;
138 vn_encode_uint64_t(enc, &tmp);
139 }
140
141 static inline void
vn_decode_size_t(struct vn_cs_decoder * dec,size_t * val)142 vn_decode_size_t(struct vn_cs_decoder *dec, size_t *val)
143 {
144 uint64_t tmp;
145 vn_decode_uint64_t(dec, &tmp);
146 *val = tmp;
147 }
148
149 static inline size_t
vn_sizeof_size_t_array(const size_t * val,uint32_t count)150 vn_sizeof_size_t_array(const size_t *val, uint32_t count)
151 {
152 return vn_sizeof_size_t(val) * count;
153 }
154
155 static inline void
vn_encode_size_t_array(struct vn_cs_encoder * enc,const size_t * val,uint32_t count)156 vn_encode_size_t_array(struct vn_cs_encoder *enc, const size_t *val, uint32_t count)
157 {
158 if (sizeof(size_t) == sizeof(uint64_t)) {
159 vn_encode_uint64_t_array(enc, (const uint64_t *)val, count);
160 } else {
161 for (uint32_t i = 0; i < count; i++)
162 vn_encode_size_t(enc, &val[i]);
163 }
164 }
165
166 static inline void
vn_decode_size_t_array(struct vn_cs_decoder * dec,size_t * val,uint32_t count)167 vn_decode_size_t_array(struct vn_cs_decoder *dec, size_t *val, uint32_t count)
168 {
169 if (sizeof(size_t) == sizeof(uint64_t)) {
170 vn_decode_uint64_t_array(dec, (uint64_t *)val, count);
171 } else {
172 for (uint32_t i = 0; i < count; i++)
173 vn_decode_size_t(dec, &val[i]);
174 }
175 }
176
177 /* opaque blob */
178
179 static inline size_t
vn_sizeof_blob_array(const void * val,size_t size)180 vn_sizeof_blob_array(const void *val, size_t size)
181 {
182 return (size + 3) & ~3;
183 }
184
185 static inline void
vn_encode_blob_array(struct vn_cs_encoder * enc,const void * val,size_t size)186 vn_encode_blob_array(struct vn_cs_encoder *enc, const void *val, size_t size)
187 {
188 vn_encode(enc, (size + 3) & ~3, val, size);
189 }
190
191 static inline void
vn_decode_blob_array(struct vn_cs_decoder * dec,void * val,size_t size)192 vn_decode_blob_array(struct vn_cs_decoder *dec, void *val, size_t size)
193 {
194 vn_decode(dec, (size + 3) & ~3, val, size);
195 }
196
197 /* string */
198
199 static inline size_t
vn_sizeof_char_array(const char * val,size_t size)200 vn_sizeof_char_array(const char *val, size_t size)
201 {
202 return vn_sizeof_blob_array(val, size);
203 }
204
205 static inline void
vn_encode_char_array(struct vn_cs_encoder * enc,const char * val,size_t size)206 vn_encode_char_array(struct vn_cs_encoder *enc, const char *val, size_t size)
207 {
208 assert(size && strlen(val) < size);
209 vn_encode_blob_array(enc, val, size);
210 }
211
212 static inline void
vn_decode_char_array(struct vn_cs_decoder * dec,char * val,size_t size)213 vn_decode_char_array(struct vn_cs_decoder *dec, char *val, size_t size)
214 {
215 vn_decode_blob_array(dec, val, size);
216 if (size)
217 val[size - 1] = '\0';
218 else
219 vn_cs_decoder_set_fatal(dec);
220 }
221
222 /* array size (uint64_t) */
223
224 static inline size_t
vn_sizeof_array_size(uint64_t size)225 vn_sizeof_array_size(uint64_t size)
226 {
227 return vn_sizeof_uint64_t(&size);
228 }
229
230 static inline void
vn_encode_array_size(struct vn_cs_encoder * enc,uint64_t size)231 vn_encode_array_size(struct vn_cs_encoder *enc, uint64_t size)
232 {
233 vn_encode_uint64_t(enc, &size);
234 }
235
236 static inline uint64_t
vn_decode_array_size(struct vn_cs_decoder * dec,uint64_t expected_size)237 vn_decode_array_size(struct vn_cs_decoder *dec, uint64_t expected_size)
238 {
239 uint64_t size;
240 vn_decode_uint64_t(dec, &size);
241 if (size != expected_size) {
242 vn_cs_decoder_set_fatal(dec);
243 size = 0;
244 }
245 return size;
246 }
247
248 static inline uint64_t
vn_decode_array_size_unchecked(struct vn_cs_decoder * dec)249 vn_decode_array_size_unchecked(struct vn_cs_decoder *dec)
250 {
251 uint64_t size;
252 vn_decode_uint64_t(dec, &size);
253 return size;
254 }
255
256 static inline uint64_t
vn_peek_array_size(struct vn_cs_decoder * dec)257 vn_peek_array_size(struct vn_cs_decoder *dec)
258 {
259 uint64_t size;
260 vn_cs_decoder_peek(dec, sizeof(size), &size, sizeof(size));
261 return size;
262 }
263
264 /* non-array pointer */
265
266 static inline size_t
vn_sizeof_simple_pointer(const void * val)267 vn_sizeof_simple_pointer(const void *val)
268 {
269 return vn_sizeof_array_size(val ? 1 : 0);
270 }
271
272 static inline bool
vn_encode_simple_pointer(struct vn_cs_encoder * enc,const void * val)273 vn_encode_simple_pointer(struct vn_cs_encoder *enc, const void *val)
274 {
275 vn_encode_array_size(enc, val ? 1 : 0);
276 return val;
277 }
278
279 static inline bool
vn_decode_simple_pointer(struct vn_cs_decoder * dec)280 vn_decode_simple_pointer(struct vn_cs_decoder *dec)
281 {
282 return vn_decode_array_size_unchecked(dec);
283 }
284
285 /* uint32_t */
286
287 static inline size_t
vn_sizeof_uint32_t(const uint32_t * val)288 vn_sizeof_uint32_t(const uint32_t *val)
289 {
290 assert(sizeof(*val) == 4);
291 return 4;
292 }
293
294 static inline void
vn_encode_uint32_t(struct vn_cs_encoder * enc,const uint32_t * val)295 vn_encode_uint32_t(struct vn_cs_encoder *enc, const uint32_t *val)
296 {
297 vn_encode(enc, 4, val, sizeof(*val));
298 }
299
300 static inline void
vn_decode_uint32_t(struct vn_cs_decoder * dec,uint32_t * val)301 vn_decode_uint32_t(struct vn_cs_decoder *dec, uint32_t *val)
302 {
303 vn_decode(dec, 4, val, sizeof(*val));
304 }
305
306 static inline size_t
vn_sizeof_uint32_t_array(const uint32_t * val,uint32_t count)307 vn_sizeof_uint32_t_array(const uint32_t *val, uint32_t count)
308 {
309 assert(sizeof(*val) == 4);
310 const size_t size = sizeof(*val) * count;
311 assert(size >= count);
312 return size;
313 }
314
315 static inline void
vn_encode_uint32_t_array(struct vn_cs_encoder * enc,const uint32_t * val,uint32_t count)316 vn_encode_uint32_t_array(struct vn_cs_encoder *enc, const uint32_t *val, uint32_t count)
317 {
318 const size_t size = sizeof(*val) * count;
319 assert(size >= count);
320 vn_encode(enc, size, val, size);
321 }
322
323 static inline void
vn_decode_uint32_t_array(struct vn_cs_decoder * dec,uint32_t * val,uint32_t count)324 vn_decode_uint32_t_array(struct vn_cs_decoder *dec, uint32_t *val, uint32_t count)
325 {
326 const size_t size = sizeof(*val) * count;
327 assert(size >= count);
328 vn_decode(dec, size, val, size);
329 }
330
331 /* float */
332
333 static inline size_t
vn_sizeof_float(const float * val)334 vn_sizeof_float(const float *val)
335 {
336 assert(sizeof(*val) == 4);
337 return 4;
338 }
339
340 static inline void
vn_encode_float(struct vn_cs_encoder * enc,const float * val)341 vn_encode_float(struct vn_cs_encoder *enc, const float *val)
342 {
343 vn_encode(enc, 4, val, sizeof(*val));
344 }
345
346 static inline void
vn_decode_float(struct vn_cs_decoder * dec,float * val)347 vn_decode_float(struct vn_cs_decoder *dec, float *val)
348 {
349 vn_decode(dec, 4, val, sizeof(*val));
350 }
351
352 static inline size_t
vn_sizeof_float_array(const float * val,uint32_t count)353 vn_sizeof_float_array(const float *val, uint32_t count)
354 {
355 assert(sizeof(*val) == 4);
356 const size_t size = sizeof(*val) * count;
357 assert(size >= count);
358 return size;
359 }
360
361 static inline void
vn_encode_float_array(struct vn_cs_encoder * enc,const float * val,uint32_t count)362 vn_encode_float_array(struct vn_cs_encoder *enc, const float *val, uint32_t count)
363 {
364 const size_t size = sizeof(*val) * count;
365 assert(size >= count);
366 vn_encode(enc, size, val, size);
367 }
368
369 static inline void
vn_decode_float_array(struct vn_cs_decoder * dec,float * val,uint32_t count)370 vn_decode_float_array(struct vn_cs_decoder *dec, float *val, uint32_t count)
371 {
372 const size_t size = sizeof(*val) * count;
373 assert(size >= count);
374 vn_decode(dec, size, val, size);
375 }
376
377 /* uint8_t */
378
379 static inline size_t
vn_sizeof_uint8_t(const uint8_t * val)380 vn_sizeof_uint8_t(const uint8_t *val)
381 {
382 assert(sizeof(*val) == 1);
383 return 4;
384 }
385
386 static inline void
vn_encode_uint8_t(struct vn_cs_encoder * enc,const uint8_t * val)387 vn_encode_uint8_t(struct vn_cs_encoder *enc, const uint8_t *val)
388 {
389 vn_encode(enc, 4, val, sizeof(*val));
390 }
391
392 static inline void
vn_decode_uint8_t(struct vn_cs_decoder * dec,uint8_t * val)393 vn_decode_uint8_t(struct vn_cs_decoder *dec, uint8_t *val)
394 {
395 vn_decode(dec, 4, val, sizeof(*val));
396 }
397
398 static inline size_t
vn_sizeof_uint8_t_array(const uint8_t * val,uint32_t count)399 vn_sizeof_uint8_t_array(const uint8_t *val, uint32_t count)
400 {
401 assert(sizeof(*val) == 1);
402 const size_t size = sizeof(*val) * count;
403 assert(size >= count);
404 return (size + 3) & ~3;
405 }
406
407 static inline void
vn_encode_uint8_t_array(struct vn_cs_encoder * enc,const uint8_t * val,uint32_t count)408 vn_encode_uint8_t_array(struct vn_cs_encoder *enc, const uint8_t *val, uint32_t count)
409 {
410 const size_t size = sizeof(*val) * count;
411 assert(size >= count);
412 vn_encode(enc, (size + 3) & ~3, val, size);
413 }
414
415 static inline void
vn_decode_uint8_t_array(struct vn_cs_decoder * dec,uint8_t * val,uint32_t count)416 vn_decode_uint8_t_array(struct vn_cs_decoder *dec, uint8_t *val, uint32_t count)
417 {
418 const size_t size = sizeof(*val) * count;
419 assert(size >= count);
420 vn_decode(dec, (size + 3) & ~3, val, size);
421 }
422
423 /* typedef uint32_t VkSampleMask */
424
425 static inline size_t
vn_sizeof_VkSampleMask(const VkSampleMask * val)426 vn_sizeof_VkSampleMask(const VkSampleMask *val)
427 {
428 return vn_sizeof_uint32_t(val);
429 }
430
431 static inline void
vn_encode_VkSampleMask(struct vn_cs_encoder * enc,const VkSampleMask * val)432 vn_encode_VkSampleMask(struct vn_cs_encoder *enc, const VkSampleMask *val)
433 {
434 vn_encode_uint32_t(enc, val);
435 }
436
437 static inline void
vn_decode_VkSampleMask(struct vn_cs_decoder * dec,VkSampleMask * val)438 vn_decode_VkSampleMask(struct vn_cs_decoder *dec, VkSampleMask *val)
439 {
440 vn_decode_uint32_t(dec, val);
441 }
442
443 static inline size_t
vn_sizeof_VkSampleMask_array(const VkSampleMask * val,uint32_t count)444 vn_sizeof_VkSampleMask_array(const VkSampleMask *val, uint32_t count)
445 {
446 return vn_sizeof_uint32_t_array(val, count);
447 }
448
449 static inline void
vn_encode_VkSampleMask_array(struct vn_cs_encoder * enc,const VkSampleMask * val,uint32_t count)450 vn_encode_VkSampleMask_array(struct vn_cs_encoder *enc, const VkSampleMask *val, uint32_t count)
451 {
452 vn_encode_uint32_t_array(enc, val, count);
453 }
454
455 static inline void
vn_decode_VkSampleMask_array(struct vn_cs_decoder * dec,VkSampleMask * val,uint32_t count)456 vn_decode_VkSampleMask_array(struct vn_cs_decoder *dec, VkSampleMask *val, uint32_t count)
457 {
458 vn_decode_uint32_t_array(dec, val, count);
459 }
460
461 /* typedef uint32_t VkBool32 */
462
463 static inline size_t
vn_sizeof_VkBool32(const VkBool32 * val)464 vn_sizeof_VkBool32(const VkBool32 *val)
465 {
466 return vn_sizeof_uint32_t(val);
467 }
468
469 static inline void
vn_encode_VkBool32(struct vn_cs_encoder * enc,const VkBool32 * val)470 vn_encode_VkBool32(struct vn_cs_encoder *enc, const VkBool32 *val)
471 {
472 vn_encode_uint32_t(enc, val);
473 }
474
475 static inline void
vn_decode_VkBool32(struct vn_cs_decoder * dec,VkBool32 * val)476 vn_decode_VkBool32(struct vn_cs_decoder *dec, VkBool32 *val)
477 {
478 vn_decode_uint32_t(dec, val);
479 }
480
481 static inline size_t
vn_sizeof_VkBool32_array(const VkBool32 * val,uint32_t count)482 vn_sizeof_VkBool32_array(const VkBool32 *val, uint32_t count)
483 {
484 return vn_sizeof_uint32_t_array(val, count);
485 }
486
487 static inline void
vn_encode_VkBool32_array(struct vn_cs_encoder * enc,const VkBool32 * val,uint32_t count)488 vn_encode_VkBool32_array(struct vn_cs_encoder *enc, const VkBool32 *val, uint32_t count)
489 {
490 vn_encode_uint32_t_array(enc, val, count);
491 }
492
493 static inline void
vn_decode_VkBool32_array(struct vn_cs_decoder * dec,VkBool32 * val,uint32_t count)494 vn_decode_VkBool32_array(struct vn_cs_decoder *dec, VkBool32 *val, uint32_t count)
495 {
496 vn_decode_uint32_t_array(dec, val, count);
497 }
498
499 /* typedef uint32_t VkFlags */
500
501 static inline size_t
vn_sizeof_VkFlags(const VkFlags * val)502 vn_sizeof_VkFlags(const VkFlags *val)
503 {
504 return vn_sizeof_uint32_t(val);
505 }
506
507 static inline void
vn_encode_VkFlags(struct vn_cs_encoder * enc,const VkFlags * val)508 vn_encode_VkFlags(struct vn_cs_encoder *enc, const VkFlags *val)
509 {
510 vn_encode_uint32_t(enc, val);
511 }
512
513 static inline void
vn_decode_VkFlags(struct vn_cs_decoder * dec,VkFlags * val)514 vn_decode_VkFlags(struct vn_cs_decoder *dec, VkFlags *val)
515 {
516 vn_decode_uint32_t(dec, val);
517 }
518
519 static inline size_t
vn_sizeof_VkFlags_array(const VkFlags * val,uint32_t count)520 vn_sizeof_VkFlags_array(const VkFlags *val, uint32_t count)
521 {
522 return vn_sizeof_uint32_t_array(val, count);
523 }
524
525 static inline void
vn_encode_VkFlags_array(struct vn_cs_encoder * enc,const VkFlags * val,uint32_t count)526 vn_encode_VkFlags_array(struct vn_cs_encoder *enc, const VkFlags *val, uint32_t count)
527 {
528 vn_encode_uint32_t_array(enc, val, count);
529 }
530
531 static inline void
vn_decode_VkFlags_array(struct vn_cs_decoder * dec,VkFlags * val,uint32_t count)532 vn_decode_VkFlags_array(struct vn_cs_decoder *dec, VkFlags *val, uint32_t count)
533 {
534 vn_decode_uint32_t_array(dec, val, count);
535 }
536
537 /* typedef uint64_t VkDeviceSize */
538
539 static inline size_t
vn_sizeof_VkDeviceSize(const VkDeviceSize * val)540 vn_sizeof_VkDeviceSize(const VkDeviceSize *val)
541 {
542 return vn_sizeof_uint64_t(val);
543 }
544
545 static inline void
vn_encode_VkDeviceSize(struct vn_cs_encoder * enc,const VkDeviceSize * val)546 vn_encode_VkDeviceSize(struct vn_cs_encoder *enc, const VkDeviceSize *val)
547 {
548 vn_encode_uint64_t(enc, val);
549 }
550
551 static inline void
vn_decode_VkDeviceSize(struct vn_cs_decoder * dec,VkDeviceSize * val)552 vn_decode_VkDeviceSize(struct vn_cs_decoder *dec, VkDeviceSize *val)
553 {
554 vn_decode_uint64_t(dec, val);
555 }
556
557 static inline size_t
vn_sizeof_VkDeviceSize_array(const VkDeviceSize * val,uint32_t count)558 vn_sizeof_VkDeviceSize_array(const VkDeviceSize *val, uint32_t count)
559 {
560 return vn_sizeof_uint64_t_array(val, count);
561 }
562
563 static inline void
vn_encode_VkDeviceSize_array(struct vn_cs_encoder * enc,const VkDeviceSize * val,uint32_t count)564 vn_encode_VkDeviceSize_array(struct vn_cs_encoder *enc, const VkDeviceSize *val, uint32_t count)
565 {
566 vn_encode_uint64_t_array(enc, val, count);
567 }
568
569 static inline void
vn_decode_VkDeviceSize_array(struct vn_cs_decoder * dec,VkDeviceSize * val,uint32_t count)570 vn_decode_VkDeviceSize_array(struct vn_cs_decoder *dec, VkDeviceSize *val, uint32_t count)
571 {
572 vn_decode_uint64_t_array(dec, val, count);
573 }
574
575 /* typedef uint64_t VkDeviceAddress */
576
577 static inline size_t
vn_sizeof_VkDeviceAddress(const VkDeviceAddress * val)578 vn_sizeof_VkDeviceAddress(const VkDeviceAddress *val)
579 {
580 return vn_sizeof_uint64_t(val);
581 }
582
583 static inline void
vn_encode_VkDeviceAddress(struct vn_cs_encoder * enc,const VkDeviceAddress * val)584 vn_encode_VkDeviceAddress(struct vn_cs_encoder *enc, const VkDeviceAddress *val)
585 {
586 vn_encode_uint64_t(enc, val);
587 }
588
589 static inline void
vn_decode_VkDeviceAddress(struct vn_cs_decoder * dec,VkDeviceAddress * val)590 vn_decode_VkDeviceAddress(struct vn_cs_decoder *dec, VkDeviceAddress *val)
591 {
592 vn_decode_uint64_t(dec, val);
593 }
594
595 static inline size_t
vn_sizeof_VkDeviceAddress_array(const VkDeviceAddress * val,uint32_t count)596 vn_sizeof_VkDeviceAddress_array(const VkDeviceAddress *val, uint32_t count)
597 {
598 return vn_sizeof_uint64_t_array(val, count);
599 }
600
601 static inline void
vn_encode_VkDeviceAddress_array(struct vn_cs_encoder * enc,const VkDeviceAddress * val,uint32_t count)602 vn_encode_VkDeviceAddress_array(struct vn_cs_encoder *enc, const VkDeviceAddress *val, uint32_t count)
603 {
604 vn_encode_uint64_t_array(enc, val, count);
605 }
606
607 static inline void
vn_decode_VkDeviceAddress_array(struct vn_cs_decoder * dec,VkDeviceAddress * val,uint32_t count)608 vn_decode_VkDeviceAddress_array(struct vn_cs_decoder *dec, VkDeviceAddress *val, uint32_t count)
609 {
610 vn_decode_uint64_t_array(dec, val, count);
611 }
612
613 /* enum VkFramebufferCreateFlagBits */
614
615 static inline size_t
vn_sizeof_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits * val)616 vn_sizeof_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits *val)
617 {
618 assert(sizeof(*val) == sizeof(int32_t));
619 return vn_sizeof_int32_t((const int32_t *)val);
620 }
621
622 static inline void
vn_encode_VkFramebufferCreateFlagBits(struct vn_cs_encoder * enc,const VkFramebufferCreateFlagBits * val)623 vn_encode_VkFramebufferCreateFlagBits(struct vn_cs_encoder *enc, const VkFramebufferCreateFlagBits *val)
624 {
625 vn_encode_int32_t(enc, (const int32_t *)val);
626 }
627
628 static inline void
vn_decode_VkFramebufferCreateFlagBits(struct vn_cs_decoder * dec,VkFramebufferCreateFlagBits * val)629 vn_decode_VkFramebufferCreateFlagBits(struct vn_cs_decoder *dec, VkFramebufferCreateFlagBits *val)
630 {
631 vn_decode_int32_t(dec, (int32_t *)val);
632 }
633
634 /* enum VkRenderPassCreateFlagBits */
635
636 static inline size_t
vn_sizeof_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits * val)637 vn_sizeof_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits *val)
638 {
639 assert(sizeof(*val) == sizeof(int32_t));
640 return vn_sizeof_int32_t((const int32_t *)val);
641 }
642
643 static inline void
vn_encode_VkRenderPassCreateFlagBits(struct vn_cs_encoder * enc,const VkRenderPassCreateFlagBits * val)644 vn_encode_VkRenderPassCreateFlagBits(struct vn_cs_encoder *enc, const VkRenderPassCreateFlagBits *val)
645 {
646 vn_encode_int32_t(enc, (const int32_t *)val);
647 }
648
649 static inline void
vn_decode_VkRenderPassCreateFlagBits(struct vn_cs_decoder * dec,VkRenderPassCreateFlagBits * val)650 vn_decode_VkRenderPassCreateFlagBits(struct vn_cs_decoder *dec, VkRenderPassCreateFlagBits *val)
651 {
652 vn_decode_int32_t(dec, (int32_t *)val);
653 }
654
655 /* enum VkSamplerCreateFlagBits */
656
657 static inline size_t
vn_sizeof_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits * val)658 vn_sizeof_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits *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_VkSamplerCreateFlagBits(struct vn_cs_encoder * enc,const VkSamplerCreateFlagBits * val)665 vn_encode_VkSamplerCreateFlagBits(struct vn_cs_encoder *enc, const VkSamplerCreateFlagBits *val)
666 {
667 vn_encode_int32_t(enc, (const int32_t *)val);
668 }
669
670 static inline void
vn_decode_VkSamplerCreateFlagBits(struct vn_cs_decoder * dec,VkSamplerCreateFlagBits * val)671 vn_decode_VkSamplerCreateFlagBits(struct vn_cs_decoder *dec, VkSamplerCreateFlagBits *val)
672 {
673 vn_decode_int32_t(dec, (int32_t *)val);
674 }
675
676 /* enum VkPipelineCacheCreateFlagBits */
677
678 static inline size_t
vn_sizeof_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits * val)679 vn_sizeof_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits *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_VkPipelineCacheCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineCacheCreateFlagBits * val)686 vn_encode_VkPipelineCacheCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCacheCreateFlagBits *val)
687 {
688 vn_encode_int32_t(enc, (const int32_t *)val);
689 }
690
691 static inline void
vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineCacheCreateFlagBits * val)692 vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCacheCreateFlagBits *val)
693 {
694 vn_decode_int32_t(dec, (int32_t *)val);
695 }
696
697 /* enum VkPipelineShaderStageCreateFlagBits */
698
699 static inline size_t
vn_sizeof_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits * val)700 vn_sizeof_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits *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_VkPipelineShaderStageCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineShaderStageCreateFlagBits * val)707 vn_encode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateFlagBits *val)
708 {
709 vn_encode_int32_t(enc, (const int32_t *)val);
710 }
711
712 static inline void
vn_decode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineShaderStageCreateFlagBits * val)713 vn_decode_VkPipelineShaderStageCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateFlagBits *val)
714 {
715 vn_decode_int32_t(dec, (int32_t *)val);
716 }
717
718 /* enum VkDescriptorSetLayoutCreateFlagBits */
719
720 static inline size_t
vn_sizeof_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits * val)721 vn_sizeof_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits *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_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_encoder * enc,const VkDescriptorSetLayoutCreateFlagBits * val)728 vn_encode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateFlagBits *val)
729 {
730 vn_encode_int32_t(enc, (const int32_t *)val);
731 }
732
733 static inline void
vn_decode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_decoder * dec,VkDescriptorSetLayoutCreateFlagBits * val)734 vn_decode_VkDescriptorSetLayoutCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorSetLayoutCreateFlagBits *val)
735 {
736 vn_decode_int32_t(dec, (int32_t *)val);
737 }
738
739 /* enum VkDeviceQueueCreateFlagBits */
740
741 static inline size_t
vn_sizeof_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits * val)742 vn_sizeof_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits *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_VkDeviceQueueCreateFlagBits(struct vn_cs_encoder * enc,const VkDeviceQueueCreateFlagBits * val)749 vn_encode_VkDeviceQueueCreateFlagBits(struct vn_cs_encoder *enc, const VkDeviceQueueCreateFlagBits *val)
750 {
751 vn_encode_int32_t(enc, (const int32_t *)val);
752 }
753
754 static inline void
vn_decode_VkDeviceQueueCreateFlagBits(struct vn_cs_decoder * dec,VkDeviceQueueCreateFlagBits * val)755 vn_decode_VkDeviceQueueCreateFlagBits(struct vn_cs_decoder *dec, VkDeviceQueueCreateFlagBits *val)
756 {
757 vn_decode_int32_t(dec, (int32_t *)val);
758 }
759
760 /* enum VkQueueFlagBits */
761
762 static inline size_t
vn_sizeof_VkQueueFlagBits(const VkQueueFlagBits * val)763 vn_sizeof_VkQueueFlagBits(const VkQueueFlagBits *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_VkQueueFlagBits(struct vn_cs_encoder * enc,const VkQueueFlagBits * val)770 vn_encode_VkQueueFlagBits(struct vn_cs_encoder *enc, const VkQueueFlagBits *val)
771 {
772 vn_encode_int32_t(enc, (const int32_t *)val);
773 }
774
775 static inline void
vn_decode_VkQueueFlagBits(struct vn_cs_decoder * dec,VkQueueFlagBits * val)776 vn_decode_VkQueueFlagBits(struct vn_cs_decoder *dec, VkQueueFlagBits *val)
777 {
778 vn_decode_int32_t(dec, (int32_t *)val);
779 }
780
781 /* enum VkMemoryPropertyFlagBits */
782
783 static inline size_t
vn_sizeof_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits * val)784 vn_sizeof_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits *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_VkMemoryPropertyFlagBits(struct vn_cs_encoder * enc,const VkMemoryPropertyFlagBits * val)791 vn_encode_VkMemoryPropertyFlagBits(struct vn_cs_encoder *enc, const VkMemoryPropertyFlagBits *val)
792 {
793 vn_encode_int32_t(enc, (const int32_t *)val);
794 }
795
796 static inline void
vn_decode_VkMemoryPropertyFlagBits(struct vn_cs_decoder * dec,VkMemoryPropertyFlagBits * val)797 vn_decode_VkMemoryPropertyFlagBits(struct vn_cs_decoder *dec, VkMemoryPropertyFlagBits *val)
798 {
799 vn_decode_int32_t(dec, (int32_t *)val);
800 }
801
802 /* enum VkMemoryHeapFlagBits */
803
804 static inline size_t
vn_sizeof_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits * val)805 vn_sizeof_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits *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_VkMemoryHeapFlagBits(struct vn_cs_encoder * enc,const VkMemoryHeapFlagBits * val)812 vn_encode_VkMemoryHeapFlagBits(struct vn_cs_encoder *enc, const VkMemoryHeapFlagBits *val)
813 {
814 vn_encode_int32_t(enc, (const int32_t *)val);
815 }
816
817 static inline void
vn_decode_VkMemoryHeapFlagBits(struct vn_cs_decoder * dec,VkMemoryHeapFlagBits * val)818 vn_decode_VkMemoryHeapFlagBits(struct vn_cs_decoder *dec, VkMemoryHeapFlagBits *val)
819 {
820 vn_decode_int32_t(dec, (int32_t *)val);
821 }
822
823 /* enum VkAccessFlagBits */
824
825 static inline size_t
vn_sizeof_VkAccessFlagBits(const VkAccessFlagBits * val)826 vn_sizeof_VkAccessFlagBits(const VkAccessFlagBits *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_VkAccessFlagBits(struct vn_cs_encoder * enc,const VkAccessFlagBits * val)833 vn_encode_VkAccessFlagBits(struct vn_cs_encoder *enc, const VkAccessFlagBits *val)
834 {
835 vn_encode_int32_t(enc, (const int32_t *)val);
836 }
837
838 static inline void
vn_decode_VkAccessFlagBits(struct vn_cs_decoder * dec,VkAccessFlagBits * val)839 vn_decode_VkAccessFlagBits(struct vn_cs_decoder *dec, VkAccessFlagBits *val)
840 {
841 vn_decode_int32_t(dec, (int32_t *)val);
842 }
843
844 /* enum VkBufferUsageFlagBits */
845
846 static inline size_t
vn_sizeof_VkBufferUsageFlagBits(const VkBufferUsageFlagBits * val)847 vn_sizeof_VkBufferUsageFlagBits(const VkBufferUsageFlagBits *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_VkBufferUsageFlagBits(struct vn_cs_encoder * enc,const VkBufferUsageFlagBits * val)854 vn_encode_VkBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkBufferUsageFlagBits *val)
855 {
856 vn_encode_int32_t(enc, (const int32_t *)val);
857 }
858
859 static inline void
vn_decode_VkBufferUsageFlagBits(struct vn_cs_decoder * dec,VkBufferUsageFlagBits * val)860 vn_decode_VkBufferUsageFlagBits(struct vn_cs_decoder *dec, VkBufferUsageFlagBits *val)
861 {
862 vn_decode_int32_t(dec, (int32_t *)val);
863 }
864
865 /* enum VkBufferCreateFlagBits */
866
867 static inline size_t
vn_sizeof_VkBufferCreateFlagBits(const VkBufferCreateFlagBits * val)868 vn_sizeof_VkBufferCreateFlagBits(const VkBufferCreateFlagBits *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_VkBufferCreateFlagBits(struct vn_cs_encoder * enc,const VkBufferCreateFlagBits * val)875 vn_encode_VkBufferCreateFlagBits(struct vn_cs_encoder *enc, const VkBufferCreateFlagBits *val)
876 {
877 vn_encode_int32_t(enc, (const int32_t *)val);
878 }
879
880 static inline void
vn_decode_VkBufferCreateFlagBits(struct vn_cs_decoder * dec,VkBufferCreateFlagBits * val)881 vn_decode_VkBufferCreateFlagBits(struct vn_cs_decoder *dec, VkBufferCreateFlagBits *val)
882 {
883 vn_decode_int32_t(dec, (int32_t *)val);
884 }
885
886 /* enum VkShaderStageFlagBits */
887
888 static inline size_t
vn_sizeof_VkShaderStageFlagBits(const VkShaderStageFlagBits * val)889 vn_sizeof_VkShaderStageFlagBits(const VkShaderStageFlagBits *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_VkShaderStageFlagBits(struct vn_cs_encoder * enc,const VkShaderStageFlagBits * val)896 vn_encode_VkShaderStageFlagBits(struct vn_cs_encoder *enc, const VkShaderStageFlagBits *val)
897 {
898 vn_encode_int32_t(enc, (const int32_t *)val);
899 }
900
901 static inline void
vn_decode_VkShaderStageFlagBits(struct vn_cs_decoder * dec,VkShaderStageFlagBits * val)902 vn_decode_VkShaderStageFlagBits(struct vn_cs_decoder *dec, VkShaderStageFlagBits *val)
903 {
904 vn_decode_int32_t(dec, (int32_t *)val);
905 }
906
907 /* enum VkImageUsageFlagBits */
908
909 static inline size_t
vn_sizeof_VkImageUsageFlagBits(const VkImageUsageFlagBits * val)910 vn_sizeof_VkImageUsageFlagBits(const VkImageUsageFlagBits *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_VkImageUsageFlagBits(struct vn_cs_encoder * enc,const VkImageUsageFlagBits * val)917 vn_encode_VkImageUsageFlagBits(struct vn_cs_encoder *enc, const VkImageUsageFlagBits *val)
918 {
919 vn_encode_int32_t(enc, (const int32_t *)val);
920 }
921
922 static inline void
vn_decode_VkImageUsageFlagBits(struct vn_cs_decoder * dec,VkImageUsageFlagBits * val)923 vn_decode_VkImageUsageFlagBits(struct vn_cs_decoder *dec, VkImageUsageFlagBits *val)
924 {
925 vn_decode_int32_t(dec, (int32_t *)val);
926 }
927
928 /* enum VkImageCreateFlagBits */
929
930 static inline size_t
vn_sizeof_VkImageCreateFlagBits(const VkImageCreateFlagBits * val)931 vn_sizeof_VkImageCreateFlagBits(const VkImageCreateFlagBits *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_VkImageCreateFlagBits(struct vn_cs_encoder * enc,const VkImageCreateFlagBits * val)938 vn_encode_VkImageCreateFlagBits(struct vn_cs_encoder *enc, const VkImageCreateFlagBits *val)
939 {
940 vn_encode_int32_t(enc, (const int32_t *)val);
941 }
942
943 static inline void
vn_decode_VkImageCreateFlagBits(struct vn_cs_decoder * dec,VkImageCreateFlagBits * val)944 vn_decode_VkImageCreateFlagBits(struct vn_cs_decoder *dec, VkImageCreateFlagBits *val)
945 {
946 vn_decode_int32_t(dec, (int32_t *)val);
947 }
948
949 /* enum VkImageViewCreateFlagBits */
950
951 static inline size_t
vn_sizeof_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits * val)952 vn_sizeof_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits *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_VkImageViewCreateFlagBits(struct vn_cs_encoder * enc,const VkImageViewCreateFlagBits * val)959 vn_encode_VkImageViewCreateFlagBits(struct vn_cs_encoder *enc, const VkImageViewCreateFlagBits *val)
960 {
961 vn_encode_int32_t(enc, (const int32_t *)val);
962 }
963
964 static inline void
vn_decode_VkImageViewCreateFlagBits(struct vn_cs_decoder * dec,VkImageViewCreateFlagBits * val)965 vn_decode_VkImageViewCreateFlagBits(struct vn_cs_decoder *dec, VkImageViewCreateFlagBits *val)
966 {
967 vn_decode_int32_t(dec, (int32_t *)val);
968 }
969
970 /* enum VkPipelineCreateFlagBits */
971
972 static inline size_t
vn_sizeof_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits * val)973 vn_sizeof_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits *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_VkPipelineCreateFlagBits(struct vn_cs_encoder * enc,const VkPipelineCreateFlagBits * val)980 vn_encode_VkPipelineCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreateFlagBits *val)
981 {
982 vn_encode_int32_t(enc, (const int32_t *)val);
983 }
984
985 static inline void
vn_decode_VkPipelineCreateFlagBits(struct vn_cs_decoder * dec,VkPipelineCreateFlagBits * val)986 vn_decode_VkPipelineCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCreateFlagBits *val)
987 {
988 vn_decode_int32_t(dec, (int32_t *)val);
989 }
990
991 /* enum VkColorComponentFlagBits */
992
993 static inline size_t
vn_sizeof_VkColorComponentFlagBits(const VkColorComponentFlagBits * val)994 vn_sizeof_VkColorComponentFlagBits(const VkColorComponentFlagBits *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_VkColorComponentFlagBits(struct vn_cs_encoder * enc,const VkColorComponentFlagBits * val)1001 vn_encode_VkColorComponentFlagBits(struct vn_cs_encoder *enc, const VkColorComponentFlagBits *val)
1002 {
1003 vn_encode_int32_t(enc, (const int32_t *)val);
1004 }
1005
1006 static inline void
vn_decode_VkColorComponentFlagBits(struct vn_cs_decoder * dec,VkColorComponentFlagBits * val)1007 vn_decode_VkColorComponentFlagBits(struct vn_cs_decoder *dec, VkColorComponentFlagBits *val)
1008 {
1009 vn_decode_int32_t(dec, (int32_t *)val);
1010 }
1011
1012 /* enum VkFenceCreateFlagBits */
1013
1014 static inline size_t
vn_sizeof_VkFenceCreateFlagBits(const VkFenceCreateFlagBits * val)1015 vn_sizeof_VkFenceCreateFlagBits(const VkFenceCreateFlagBits *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_VkFenceCreateFlagBits(struct vn_cs_encoder * enc,const VkFenceCreateFlagBits * val)1022 vn_encode_VkFenceCreateFlagBits(struct vn_cs_encoder *enc, const VkFenceCreateFlagBits *val)
1023 {
1024 vn_encode_int32_t(enc, (const int32_t *)val);
1025 }
1026
1027 static inline void
vn_decode_VkFenceCreateFlagBits(struct vn_cs_decoder * dec,VkFenceCreateFlagBits * val)1028 vn_decode_VkFenceCreateFlagBits(struct vn_cs_decoder *dec, VkFenceCreateFlagBits *val)
1029 {
1030 vn_decode_int32_t(dec, (int32_t *)val);
1031 }
1032
1033 /* enum VkFormatFeatureFlagBits */
1034
1035 static inline size_t
vn_sizeof_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits * val)1036 vn_sizeof_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits *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_VkFormatFeatureFlagBits(struct vn_cs_encoder * enc,const VkFormatFeatureFlagBits * val)1043 vn_encode_VkFormatFeatureFlagBits(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits *val)
1044 {
1045 vn_encode_int32_t(enc, (const int32_t *)val);
1046 }
1047
1048 static inline void
vn_decode_VkFormatFeatureFlagBits(struct vn_cs_decoder * dec,VkFormatFeatureFlagBits * val)1049 vn_decode_VkFormatFeatureFlagBits(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits *val)
1050 {
1051 vn_decode_int32_t(dec, (int32_t *)val);
1052 }
1053
1054 /* enum VkQueryControlFlagBits */
1055
1056 static inline size_t
vn_sizeof_VkQueryControlFlagBits(const VkQueryControlFlagBits * val)1057 vn_sizeof_VkQueryControlFlagBits(const VkQueryControlFlagBits *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_VkQueryControlFlagBits(struct vn_cs_encoder * enc,const VkQueryControlFlagBits * val)1064 vn_encode_VkQueryControlFlagBits(struct vn_cs_encoder *enc, const VkQueryControlFlagBits *val)
1065 {
1066 vn_encode_int32_t(enc, (const int32_t *)val);
1067 }
1068
1069 static inline void
vn_decode_VkQueryControlFlagBits(struct vn_cs_decoder * dec,VkQueryControlFlagBits * val)1070 vn_decode_VkQueryControlFlagBits(struct vn_cs_decoder *dec, VkQueryControlFlagBits *val)
1071 {
1072 vn_decode_int32_t(dec, (int32_t *)val);
1073 }
1074
1075 /* enum VkQueryResultFlagBits */
1076
1077 static inline size_t
vn_sizeof_VkQueryResultFlagBits(const VkQueryResultFlagBits * val)1078 vn_sizeof_VkQueryResultFlagBits(const VkQueryResultFlagBits *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_VkQueryResultFlagBits(struct vn_cs_encoder * enc,const VkQueryResultFlagBits * val)1085 vn_encode_VkQueryResultFlagBits(struct vn_cs_encoder *enc, const VkQueryResultFlagBits *val)
1086 {
1087 vn_encode_int32_t(enc, (const int32_t *)val);
1088 }
1089
1090 static inline void
vn_decode_VkQueryResultFlagBits(struct vn_cs_decoder * dec,VkQueryResultFlagBits * val)1091 vn_decode_VkQueryResultFlagBits(struct vn_cs_decoder *dec, VkQueryResultFlagBits *val)
1092 {
1093 vn_decode_int32_t(dec, (int32_t *)val);
1094 }
1095
1096 /* enum VkEventCreateFlagBits */
1097
1098 static inline size_t
vn_sizeof_VkEventCreateFlagBits(const VkEventCreateFlagBits * val)1099 vn_sizeof_VkEventCreateFlagBits(const VkEventCreateFlagBits *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_VkEventCreateFlagBits(struct vn_cs_encoder * enc,const VkEventCreateFlagBits * val)1106 vn_encode_VkEventCreateFlagBits(struct vn_cs_encoder *enc, const VkEventCreateFlagBits *val)
1107 {
1108 vn_encode_int32_t(enc, (const int32_t *)val);
1109 }
1110
1111 static inline void
vn_decode_VkEventCreateFlagBits(struct vn_cs_decoder * dec,VkEventCreateFlagBits * val)1112 vn_decode_VkEventCreateFlagBits(struct vn_cs_decoder *dec, VkEventCreateFlagBits *val)
1113 {
1114 vn_decode_int32_t(dec, (int32_t *)val);
1115 }
1116
1117 /* enum VkCommandPoolCreateFlagBits */
1118
1119 static inline size_t
vn_sizeof_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits * val)1120 vn_sizeof_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits *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_VkCommandPoolCreateFlagBits(struct vn_cs_encoder * enc,const VkCommandPoolCreateFlagBits * val)1127 vn_encode_VkCommandPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolCreateFlagBits *val)
1128 {
1129 vn_encode_int32_t(enc, (const int32_t *)val);
1130 }
1131
1132 static inline void
vn_decode_VkCommandPoolCreateFlagBits(struct vn_cs_decoder * dec,VkCommandPoolCreateFlagBits * val)1133 vn_decode_VkCommandPoolCreateFlagBits(struct vn_cs_decoder *dec, VkCommandPoolCreateFlagBits *val)
1134 {
1135 vn_decode_int32_t(dec, (int32_t *)val);
1136 }
1137
1138 /* enum VkCommandPoolResetFlagBits */
1139
1140 static inline size_t
vn_sizeof_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits * val)1141 vn_sizeof_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits *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_VkCommandPoolResetFlagBits(struct vn_cs_encoder * enc,const VkCommandPoolResetFlagBits * val)1148 vn_encode_VkCommandPoolResetFlagBits(struct vn_cs_encoder *enc, const VkCommandPoolResetFlagBits *val)
1149 {
1150 vn_encode_int32_t(enc, (const int32_t *)val);
1151 }
1152
1153 static inline void
vn_decode_VkCommandPoolResetFlagBits(struct vn_cs_decoder * dec,VkCommandPoolResetFlagBits * val)1154 vn_decode_VkCommandPoolResetFlagBits(struct vn_cs_decoder *dec, VkCommandPoolResetFlagBits *val)
1155 {
1156 vn_decode_int32_t(dec, (int32_t *)val);
1157 }
1158
1159 /* enum VkCommandBufferResetFlagBits */
1160
1161 static inline size_t
vn_sizeof_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits * val)1162 vn_sizeof_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits *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_VkCommandBufferResetFlagBits(struct vn_cs_encoder * enc,const VkCommandBufferResetFlagBits * val)1169 vn_encode_VkCommandBufferResetFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferResetFlagBits *val)
1170 {
1171 vn_encode_int32_t(enc, (const int32_t *)val);
1172 }
1173
1174 static inline void
vn_decode_VkCommandBufferResetFlagBits(struct vn_cs_decoder * dec,VkCommandBufferResetFlagBits * val)1175 vn_decode_VkCommandBufferResetFlagBits(struct vn_cs_decoder *dec, VkCommandBufferResetFlagBits *val)
1176 {
1177 vn_decode_int32_t(dec, (int32_t *)val);
1178 }
1179
1180 /* enum VkCommandBufferUsageFlagBits */
1181
1182 static inline size_t
vn_sizeof_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits * val)1183 vn_sizeof_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits *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_VkCommandBufferUsageFlagBits(struct vn_cs_encoder * enc,const VkCommandBufferUsageFlagBits * val)1190 vn_encode_VkCommandBufferUsageFlagBits(struct vn_cs_encoder *enc, const VkCommandBufferUsageFlagBits *val)
1191 {
1192 vn_encode_int32_t(enc, (const int32_t *)val);
1193 }
1194
1195 static inline void
vn_decode_VkCommandBufferUsageFlagBits(struct vn_cs_decoder * dec,VkCommandBufferUsageFlagBits * val)1196 vn_decode_VkCommandBufferUsageFlagBits(struct vn_cs_decoder *dec, VkCommandBufferUsageFlagBits *val)
1197 {
1198 vn_decode_int32_t(dec, (int32_t *)val);
1199 }
1200
1201 /* enum VkQueryPipelineStatisticFlagBits */
1202
1203 static inline size_t
vn_sizeof_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits * val)1204 vn_sizeof_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits *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_VkQueryPipelineStatisticFlagBits(struct vn_cs_encoder * enc,const VkQueryPipelineStatisticFlagBits * val)1211 vn_encode_VkQueryPipelineStatisticFlagBits(struct vn_cs_encoder *enc, const VkQueryPipelineStatisticFlagBits *val)
1212 {
1213 vn_encode_int32_t(enc, (const int32_t *)val);
1214 }
1215
1216 static inline void
vn_decode_VkQueryPipelineStatisticFlagBits(struct vn_cs_decoder * dec,VkQueryPipelineStatisticFlagBits * val)1217 vn_decode_VkQueryPipelineStatisticFlagBits(struct vn_cs_decoder *dec, VkQueryPipelineStatisticFlagBits *val)
1218 {
1219 vn_decode_int32_t(dec, (int32_t *)val);
1220 }
1221
1222 /* enum VkImageAspectFlagBits */
1223
1224 static inline size_t
vn_sizeof_VkImageAspectFlagBits(const VkImageAspectFlagBits * val)1225 vn_sizeof_VkImageAspectFlagBits(const VkImageAspectFlagBits *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_VkImageAspectFlagBits(struct vn_cs_encoder * enc,const VkImageAspectFlagBits * val)1232 vn_encode_VkImageAspectFlagBits(struct vn_cs_encoder *enc, const VkImageAspectFlagBits *val)
1233 {
1234 vn_encode_int32_t(enc, (const int32_t *)val);
1235 }
1236
1237 static inline void
vn_decode_VkImageAspectFlagBits(struct vn_cs_decoder * dec,VkImageAspectFlagBits * val)1238 vn_decode_VkImageAspectFlagBits(struct vn_cs_decoder *dec, VkImageAspectFlagBits *val)
1239 {
1240 vn_decode_int32_t(dec, (int32_t *)val);
1241 }
1242
1243 /* enum VkSparseMemoryBindFlagBits */
1244
1245 static inline size_t
vn_sizeof_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits * val)1246 vn_sizeof_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits *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_VkSparseMemoryBindFlagBits(struct vn_cs_encoder * enc,const VkSparseMemoryBindFlagBits * val)1253 vn_encode_VkSparseMemoryBindFlagBits(struct vn_cs_encoder *enc, const VkSparseMemoryBindFlagBits *val)
1254 {
1255 vn_encode_int32_t(enc, (const int32_t *)val);
1256 }
1257
1258 static inline void
vn_decode_VkSparseMemoryBindFlagBits(struct vn_cs_decoder * dec,VkSparseMemoryBindFlagBits * val)1259 vn_decode_VkSparseMemoryBindFlagBits(struct vn_cs_decoder *dec, VkSparseMemoryBindFlagBits *val)
1260 {
1261 vn_decode_int32_t(dec, (int32_t *)val);
1262 }
1263
1264 /* enum VkSparseImageFormatFlagBits */
1265
1266 static inline size_t
vn_sizeof_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits * val)1267 vn_sizeof_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits *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_VkSparseImageFormatFlagBits(struct vn_cs_encoder * enc,const VkSparseImageFormatFlagBits * val)1274 vn_encode_VkSparseImageFormatFlagBits(struct vn_cs_encoder *enc, const VkSparseImageFormatFlagBits *val)
1275 {
1276 vn_encode_int32_t(enc, (const int32_t *)val);
1277 }
1278
1279 static inline void
vn_decode_VkSparseImageFormatFlagBits(struct vn_cs_decoder * dec,VkSparseImageFormatFlagBits * val)1280 vn_decode_VkSparseImageFormatFlagBits(struct vn_cs_decoder *dec, VkSparseImageFormatFlagBits *val)
1281 {
1282 vn_decode_int32_t(dec, (int32_t *)val);
1283 }
1284
1285 /* enum VkSubpassDescriptionFlagBits */
1286
1287 static inline size_t
vn_sizeof_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits * val)1288 vn_sizeof_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits *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_VkSubpassDescriptionFlagBits(struct vn_cs_encoder * enc,const VkSubpassDescriptionFlagBits * val)1295 vn_encode_VkSubpassDescriptionFlagBits(struct vn_cs_encoder *enc, const VkSubpassDescriptionFlagBits *val)
1296 {
1297 vn_encode_int32_t(enc, (const int32_t *)val);
1298 }
1299
1300 static inline void
vn_decode_VkSubpassDescriptionFlagBits(struct vn_cs_decoder * dec,VkSubpassDescriptionFlagBits * val)1301 vn_decode_VkSubpassDescriptionFlagBits(struct vn_cs_decoder *dec, VkSubpassDescriptionFlagBits *val)
1302 {
1303 vn_decode_int32_t(dec, (int32_t *)val);
1304 }
1305
1306 /* enum VkPipelineStageFlagBits */
1307
1308 static inline size_t
vn_sizeof_VkPipelineStageFlagBits(const VkPipelineStageFlagBits * val)1309 vn_sizeof_VkPipelineStageFlagBits(const VkPipelineStageFlagBits *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_VkPipelineStageFlagBits(struct vn_cs_encoder * enc,const VkPipelineStageFlagBits * val)1316 vn_encode_VkPipelineStageFlagBits(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits *val)
1317 {
1318 vn_encode_int32_t(enc, (const int32_t *)val);
1319 }
1320
1321 static inline void
vn_decode_VkPipelineStageFlagBits(struct vn_cs_decoder * dec,VkPipelineStageFlagBits * val)1322 vn_decode_VkPipelineStageFlagBits(struct vn_cs_decoder *dec, VkPipelineStageFlagBits *val)
1323 {
1324 vn_decode_int32_t(dec, (int32_t *)val);
1325 }
1326
1327 /* enum VkSampleCountFlagBits */
1328
1329 static inline size_t
vn_sizeof_VkSampleCountFlagBits(const VkSampleCountFlagBits * val)1330 vn_sizeof_VkSampleCountFlagBits(const VkSampleCountFlagBits *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_VkSampleCountFlagBits(struct vn_cs_encoder * enc,const VkSampleCountFlagBits * val)1337 vn_encode_VkSampleCountFlagBits(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val)
1338 {
1339 vn_encode_int32_t(enc, (const int32_t *)val);
1340 }
1341
1342 static inline void
vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder * dec,VkSampleCountFlagBits * val)1343 vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val)
1344 {
1345 vn_decode_int32_t(dec, (int32_t *)val);
1346 }
1347
1348 /* enum VkAttachmentDescriptionFlagBits */
1349
1350 static inline size_t
vn_sizeof_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits * val)1351 vn_sizeof_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits *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_VkAttachmentDescriptionFlagBits(struct vn_cs_encoder * enc,const VkAttachmentDescriptionFlagBits * val)1358 vn_encode_VkAttachmentDescriptionFlagBits(struct vn_cs_encoder *enc, const VkAttachmentDescriptionFlagBits *val)
1359 {
1360 vn_encode_int32_t(enc, (const int32_t *)val);
1361 }
1362
1363 static inline void
vn_decode_VkAttachmentDescriptionFlagBits(struct vn_cs_decoder * dec,VkAttachmentDescriptionFlagBits * val)1364 vn_decode_VkAttachmentDescriptionFlagBits(struct vn_cs_decoder *dec, VkAttachmentDescriptionFlagBits *val)
1365 {
1366 vn_decode_int32_t(dec, (int32_t *)val);
1367 }
1368
1369 /* enum VkStencilFaceFlagBits */
1370
1371 static inline size_t
vn_sizeof_VkStencilFaceFlagBits(const VkStencilFaceFlagBits * val)1372 vn_sizeof_VkStencilFaceFlagBits(const VkStencilFaceFlagBits *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_VkStencilFaceFlagBits(struct vn_cs_encoder * enc,const VkStencilFaceFlagBits * val)1379 vn_encode_VkStencilFaceFlagBits(struct vn_cs_encoder *enc, const VkStencilFaceFlagBits *val)
1380 {
1381 vn_encode_int32_t(enc, (const int32_t *)val);
1382 }
1383
1384 static inline void
vn_decode_VkStencilFaceFlagBits(struct vn_cs_decoder * dec,VkStencilFaceFlagBits * val)1385 vn_decode_VkStencilFaceFlagBits(struct vn_cs_decoder *dec, VkStencilFaceFlagBits *val)
1386 {
1387 vn_decode_int32_t(dec, (int32_t *)val);
1388 }
1389
1390 /* enum VkCullModeFlagBits */
1391
1392 static inline size_t
vn_sizeof_VkCullModeFlagBits(const VkCullModeFlagBits * val)1393 vn_sizeof_VkCullModeFlagBits(const VkCullModeFlagBits *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_VkCullModeFlagBits(struct vn_cs_encoder * enc,const VkCullModeFlagBits * val)1400 vn_encode_VkCullModeFlagBits(struct vn_cs_encoder *enc, const VkCullModeFlagBits *val)
1401 {
1402 vn_encode_int32_t(enc, (const int32_t *)val);
1403 }
1404
1405 static inline void
vn_decode_VkCullModeFlagBits(struct vn_cs_decoder * dec,VkCullModeFlagBits * val)1406 vn_decode_VkCullModeFlagBits(struct vn_cs_decoder *dec, VkCullModeFlagBits *val)
1407 {
1408 vn_decode_int32_t(dec, (int32_t *)val);
1409 }
1410
1411 /* enum VkDescriptorPoolCreateFlagBits */
1412
1413 static inline size_t
vn_sizeof_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits * val)1414 vn_sizeof_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits *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_VkDescriptorPoolCreateFlagBits(struct vn_cs_encoder * enc,const VkDescriptorPoolCreateFlagBits * val)1421 vn_encode_VkDescriptorPoolCreateFlagBits(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateFlagBits *val)
1422 {
1423 vn_encode_int32_t(enc, (const int32_t *)val);
1424 }
1425
1426 static inline void
vn_decode_VkDescriptorPoolCreateFlagBits(struct vn_cs_decoder * dec,VkDescriptorPoolCreateFlagBits * val)1427 vn_decode_VkDescriptorPoolCreateFlagBits(struct vn_cs_decoder *dec, VkDescriptorPoolCreateFlagBits *val)
1428 {
1429 vn_decode_int32_t(dec, (int32_t *)val);
1430 }
1431
1432 /* enum VkDependencyFlagBits */
1433
1434 static inline size_t
vn_sizeof_VkDependencyFlagBits(const VkDependencyFlagBits * val)1435 vn_sizeof_VkDependencyFlagBits(const VkDependencyFlagBits *val)
1436 {
1437 assert(sizeof(*val) == sizeof(int32_t));
1438 return vn_sizeof_int32_t((const int32_t *)val);
1439 }
1440
1441 static inline void
vn_encode_VkDependencyFlagBits(struct vn_cs_encoder * enc,const VkDependencyFlagBits * val)1442 vn_encode_VkDependencyFlagBits(struct vn_cs_encoder *enc, const VkDependencyFlagBits *val)
1443 {
1444 vn_encode_int32_t(enc, (const int32_t *)val);
1445 }
1446
1447 static inline void
vn_decode_VkDependencyFlagBits(struct vn_cs_decoder * dec,VkDependencyFlagBits * val)1448 vn_decode_VkDependencyFlagBits(struct vn_cs_decoder *dec, VkDependencyFlagBits *val)
1449 {
1450 vn_decode_int32_t(dec, (int32_t *)val);
1451 }
1452
1453 /* enum VkSubgroupFeatureFlagBits */
1454
1455 static inline size_t
vn_sizeof_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits * val)1456 vn_sizeof_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits *val)
1457 {
1458 assert(sizeof(*val) == sizeof(int32_t));
1459 return vn_sizeof_int32_t((const int32_t *)val);
1460 }
1461
1462 static inline void
vn_encode_VkSubgroupFeatureFlagBits(struct vn_cs_encoder * enc,const VkSubgroupFeatureFlagBits * val)1463 vn_encode_VkSubgroupFeatureFlagBits(struct vn_cs_encoder *enc, const VkSubgroupFeatureFlagBits *val)
1464 {
1465 vn_encode_int32_t(enc, (const int32_t *)val);
1466 }
1467
1468 static inline void
vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder * dec,VkSubgroupFeatureFlagBits * val)1469 vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder *dec, VkSubgroupFeatureFlagBits *val)
1470 {
1471 vn_decode_int32_t(dec, (int32_t *)val);
1472 }
1473
1474 /* enum VkSemaphoreWaitFlagBits */
1475
1476 static inline size_t
vn_sizeof_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits * val)1477 vn_sizeof_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits *val)
1478 {
1479 assert(sizeof(*val) == sizeof(int32_t));
1480 return vn_sizeof_int32_t((const int32_t *)val);
1481 }
1482
1483 static inline void
vn_encode_VkSemaphoreWaitFlagBits(struct vn_cs_encoder * enc,const VkSemaphoreWaitFlagBits * val)1484 vn_encode_VkSemaphoreWaitFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreWaitFlagBits *val)
1485 {
1486 vn_encode_int32_t(enc, (const int32_t *)val);
1487 }
1488
1489 static inline void
vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder * dec,VkSemaphoreWaitFlagBits * val)1490 vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder *dec, VkSemaphoreWaitFlagBits *val)
1491 {
1492 vn_decode_int32_t(dec, (int32_t *)val);
1493 }
1494
1495 /* enum VkPeerMemoryFeatureFlagBits */
1496
1497 static inline size_t
vn_sizeof_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits * val)1498 vn_sizeof_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits *val)
1499 {
1500 assert(sizeof(*val) == sizeof(int32_t));
1501 return vn_sizeof_int32_t((const int32_t *)val);
1502 }
1503
1504 static inline void
vn_encode_VkPeerMemoryFeatureFlagBits(struct vn_cs_encoder * enc,const VkPeerMemoryFeatureFlagBits * val)1505 vn_encode_VkPeerMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkPeerMemoryFeatureFlagBits *val)
1506 {
1507 vn_encode_int32_t(enc, (const int32_t *)val);
1508 }
1509
1510 static inline void
vn_decode_VkPeerMemoryFeatureFlagBits(struct vn_cs_decoder * dec,VkPeerMemoryFeatureFlagBits * val)1511 vn_decode_VkPeerMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkPeerMemoryFeatureFlagBits *val)
1512 {
1513 vn_decode_int32_t(dec, (int32_t *)val);
1514 }
1515
1516 /* enum VkMemoryAllocateFlagBits */
1517
1518 static inline size_t
vn_sizeof_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits * val)1519 vn_sizeof_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits *val)
1520 {
1521 assert(sizeof(*val) == sizeof(int32_t));
1522 return vn_sizeof_int32_t((const int32_t *)val);
1523 }
1524
1525 static inline void
vn_encode_VkMemoryAllocateFlagBits(struct vn_cs_encoder * enc,const VkMemoryAllocateFlagBits * val)1526 vn_encode_VkMemoryAllocateFlagBits(struct vn_cs_encoder *enc, const VkMemoryAllocateFlagBits *val)
1527 {
1528 vn_encode_int32_t(enc, (const int32_t *)val);
1529 }
1530
1531 static inline void
vn_decode_VkMemoryAllocateFlagBits(struct vn_cs_decoder * dec,VkMemoryAllocateFlagBits * val)1532 vn_decode_VkMemoryAllocateFlagBits(struct vn_cs_decoder *dec, VkMemoryAllocateFlagBits *val)
1533 {
1534 vn_decode_int32_t(dec, (int32_t *)val);
1535 }
1536
1537 /* enum VkExternalMemoryHandleTypeFlagBits */
1538
1539 static inline size_t
vn_sizeof_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits * val)1540 vn_sizeof_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits *val)
1541 {
1542 assert(sizeof(*val) == sizeof(int32_t));
1543 return vn_sizeof_int32_t((const int32_t *)val);
1544 }
1545
1546 static inline void
vn_encode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_encoder * enc,const VkExternalMemoryHandleTypeFlagBits * val)1547 vn_encode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryHandleTypeFlagBits *val)
1548 {
1549 vn_encode_int32_t(enc, (const int32_t *)val);
1550 }
1551
1552 static inline void
vn_decode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_decoder * dec,VkExternalMemoryHandleTypeFlagBits * val)1553 vn_decode_VkExternalMemoryHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryHandleTypeFlagBits *val)
1554 {
1555 vn_decode_int32_t(dec, (int32_t *)val);
1556 }
1557
1558 /* enum VkExternalMemoryFeatureFlagBits */
1559
1560 static inline size_t
vn_sizeof_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits * val)1561 vn_sizeof_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits *val)
1562 {
1563 assert(sizeof(*val) == sizeof(int32_t));
1564 return vn_sizeof_int32_t((const int32_t *)val);
1565 }
1566
1567 static inline void
vn_encode_VkExternalMemoryFeatureFlagBits(struct vn_cs_encoder * enc,const VkExternalMemoryFeatureFlagBits * val)1568 vn_encode_VkExternalMemoryFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalMemoryFeatureFlagBits *val)
1569 {
1570 vn_encode_int32_t(enc, (const int32_t *)val);
1571 }
1572
1573 static inline void
vn_decode_VkExternalMemoryFeatureFlagBits(struct vn_cs_decoder * dec,VkExternalMemoryFeatureFlagBits * val)1574 vn_decode_VkExternalMemoryFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalMemoryFeatureFlagBits *val)
1575 {
1576 vn_decode_int32_t(dec, (int32_t *)val);
1577 }
1578
1579 /* enum VkExternalSemaphoreHandleTypeFlagBits */
1580
1581 static inline size_t
vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits * val)1582 vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits *val)
1583 {
1584 assert(sizeof(*val) == sizeof(int32_t));
1585 return vn_sizeof_int32_t((const int32_t *)val);
1586 }
1587
1588 static inline void
vn_encode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_encoder * enc,const VkExternalSemaphoreHandleTypeFlagBits * val)1589 vn_encode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreHandleTypeFlagBits *val)
1590 {
1591 vn_encode_int32_t(enc, (const int32_t *)val);
1592 }
1593
1594 static inline void
vn_decode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_decoder * dec,VkExternalSemaphoreHandleTypeFlagBits * val)1595 vn_decode_VkExternalSemaphoreHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreHandleTypeFlagBits *val)
1596 {
1597 vn_decode_int32_t(dec, (int32_t *)val);
1598 }
1599
1600 /* enum VkExternalSemaphoreFeatureFlagBits */
1601
1602 static inline size_t
vn_sizeof_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits * val)1603 vn_sizeof_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits *val)
1604 {
1605 assert(sizeof(*val) == sizeof(int32_t));
1606 return vn_sizeof_int32_t((const int32_t *)val);
1607 }
1608
1609 static inline void
vn_encode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_encoder * enc,const VkExternalSemaphoreFeatureFlagBits * val)1610 vn_encode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalSemaphoreFeatureFlagBits *val)
1611 {
1612 vn_encode_int32_t(enc, (const int32_t *)val);
1613 }
1614
1615 static inline void
vn_decode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_decoder * dec,VkExternalSemaphoreFeatureFlagBits * val)1616 vn_decode_VkExternalSemaphoreFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalSemaphoreFeatureFlagBits *val)
1617 {
1618 vn_decode_int32_t(dec, (int32_t *)val);
1619 }
1620
1621 /* enum VkSemaphoreImportFlagBits */
1622
1623 static inline size_t
vn_sizeof_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits * val)1624 vn_sizeof_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits *val)
1625 {
1626 assert(sizeof(*val) == sizeof(int32_t));
1627 return vn_sizeof_int32_t((const int32_t *)val);
1628 }
1629
1630 static inline void
vn_encode_VkSemaphoreImportFlagBits(struct vn_cs_encoder * enc,const VkSemaphoreImportFlagBits * val)1631 vn_encode_VkSemaphoreImportFlagBits(struct vn_cs_encoder *enc, const VkSemaphoreImportFlagBits *val)
1632 {
1633 vn_encode_int32_t(enc, (const int32_t *)val);
1634 }
1635
1636 static inline void
vn_decode_VkSemaphoreImportFlagBits(struct vn_cs_decoder * dec,VkSemaphoreImportFlagBits * val)1637 vn_decode_VkSemaphoreImportFlagBits(struct vn_cs_decoder *dec, VkSemaphoreImportFlagBits *val)
1638 {
1639 vn_decode_int32_t(dec, (int32_t *)val);
1640 }
1641
1642 /* enum VkExternalFenceHandleTypeFlagBits */
1643
1644 static inline size_t
vn_sizeof_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits * val)1645 vn_sizeof_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits *val)
1646 {
1647 assert(sizeof(*val) == sizeof(int32_t));
1648 return vn_sizeof_int32_t((const int32_t *)val);
1649 }
1650
1651 static inline void
vn_encode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_encoder * enc,const VkExternalFenceHandleTypeFlagBits * val)1652 vn_encode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceHandleTypeFlagBits *val)
1653 {
1654 vn_encode_int32_t(enc, (const int32_t *)val);
1655 }
1656
1657 static inline void
vn_decode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_decoder * dec,VkExternalFenceHandleTypeFlagBits * val)1658 vn_decode_VkExternalFenceHandleTypeFlagBits(struct vn_cs_decoder *dec, VkExternalFenceHandleTypeFlagBits *val)
1659 {
1660 vn_decode_int32_t(dec, (int32_t *)val);
1661 }
1662
1663 /* enum VkExternalFenceFeatureFlagBits */
1664
1665 static inline size_t
vn_sizeof_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits * val)1666 vn_sizeof_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits *val)
1667 {
1668 assert(sizeof(*val) == sizeof(int32_t));
1669 return vn_sizeof_int32_t((const int32_t *)val);
1670 }
1671
1672 static inline void
vn_encode_VkExternalFenceFeatureFlagBits(struct vn_cs_encoder * enc,const VkExternalFenceFeatureFlagBits * val)1673 vn_encode_VkExternalFenceFeatureFlagBits(struct vn_cs_encoder *enc, const VkExternalFenceFeatureFlagBits *val)
1674 {
1675 vn_encode_int32_t(enc, (const int32_t *)val);
1676 }
1677
1678 static inline void
vn_decode_VkExternalFenceFeatureFlagBits(struct vn_cs_decoder * dec,VkExternalFenceFeatureFlagBits * val)1679 vn_decode_VkExternalFenceFeatureFlagBits(struct vn_cs_decoder *dec, VkExternalFenceFeatureFlagBits *val)
1680 {
1681 vn_decode_int32_t(dec, (int32_t *)val);
1682 }
1683
1684 /* enum VkFenceImportFlagBits */
1685
1686 static inline size_t
vn_sizeof_VkFenceImportFlagBits(const VkFenceImportFlagBits * val)1687 vn_sizeof_VkFenceImportFlagBits(const VkFenceImportFlagBits *val)
1688 {
1689 assert(sizeof(*val) == sizeof(int32_t));
1690 return vn_sizeof_int32_t((const int32_t *)val);
1691 }
1692
1693 static inline void
vn_encode_VkFenceImportFlagBits(struct vn_cs_encoder * enc,const VkFenceImportFlagBits * val)1694 vn_encode_VkFenceImportFlagBits(struct vn_cs_encoder *enc, const VkFenceImportFlagBits *val)
1695 {
1696 vn_encode_int32_t(enc, (const int32_t *)val);
1697 }
1698
1699 static inline void
vn_decode_VkFenceImportFlagBits(struct vn_cs_decoder * dec,VkFenceImportFlagBits * val)1700 vn_decode_VkFenceImportFlagBits(struct vn_cs_decoder *dec, VkFenceImportFlagBits *val)
1701 {
1702 vn_decode_int32_t(dec, (int32_t *)val);
1703 }
1704
1705 /* enum VkDescriptorBindingFlagBits */
1706
1707 static inline size_t
vn_sizeof_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits * val)1708 vn_sizeof_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits *val)
1709 {
1710 assert(sizeof(*val) == sizeof(int32_t));
1711 return vn_sizeof_int32_t((const int32_t *)val);
1712 }
1713
1714 static inline void
vn_encode_VkDescriptorBindingFlagBits(struct vn_cs_encoder * enc,const VkDescriptorBindingFlagBits * val)1715 vn_encode_VkDescriptorBindingFlagBits(struct vn_cs_encoder *enc, const VkDescriptorBindingFlagBits *val)
1716 {
1717 vn_encode_int32_t(enc, (const int32_t *)val);
1718 }
1719
1720 static inline void
vn_decode_VkDescriptorBindingFlagBits(struct vn_cs_decoder * dec,VkDescriptorBindingFlagBits * val)1721 vn_decode_VkDescriptorBindingFlagBits(struct vn_cs_decoder *dec, VkDescriptorBindingFlagBits *val)
1722 {
1723 vn_decode_int32_t(dec, (int32_t *)val);
1724 }
1725
1726 /* enum VkResolveModeFlagBits */
1727
1728 static inline size_t
vn_sizeof_VkResolveModeFlagBits(const VkResolveModeFlagBits * val)1729 vn_sizeof_VkResolveModeFlagBits(const VkResolveModeFlagBits *val)
1730 {
1731 assert(sizeof(*val) == sizeof(int32_t));
1732 return vn_sizeof_int32_t((const int32_t *)val);
1733 }
1734
1735 static inline void
vn_encode_VkResolveModeFlagBits(struct vn_cs_encoder * enc,const VkResolveModeFlagBits * val)1736 vn_encode_VkResolveModeFlagBits(struct vn_cs_encoder *enc, const VkResolveModeFlagBits *val)
1737 {
1738 vn_encode_int32_t(enc, (const int32_t *)val);
1739 }
1740
1741 static inline void
vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder * dec,VkResolveModeFlagBits * val)1742 vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder *dec, VkResolveModeFlagBits *val)
1743 {
1744 vn_decode_int32_t(dec, (int32_t *)val);
1745 }
1746
1747 /* enum VkAttachmentLoadOp */
1748
1749 static inline size_t
vn_sizeof_VkAttachmentLoadOp(const VkAttachmentLoadOp * val)1750 vn_sizeof_VkAttachmentLoadOp(const VkAttachmentLoadOp *val)
1751 {
1752 assert(sizeof(*val) == sizeof(int32_t));
1753 return vn_sizeof_int32_t((const int32_t *)val);
1754 }
1755
1756 static inline void
vn_encode_VkAttachmentLoadOp(struct vn_cs_encoder * enc,const VkAttachmentLoadOp * val)1757 vn_encode_VkAttachmentLoadOp(struct vn_cs_encoder *enc, const VkAttachmentLoadOp *val)
1758 {
1759 vn_encode_int32_t(enc, (const int32_t *)val);
1760 }
1761
1762 static inline void
vn_decode_VkAttachmentLoadOp(struct vn_cs_decoder * dec,VkAttachmentLoadOp * val)1763 vn_decode_VkAttachmentLoadOp(struct vn_cs_decoder *dec, VkAttachmentLoadOp *val)
1764 {
1765 vn_decode_int32_t(dec, (int32_t *)val);
1766 }
1767
1768 /* enum VkAttachmentStoreOp */
1769
1770 static inline size_t
vn_sizeof_VkAttachmentStoreOp(const VkAttachmentStoreOp * val)1771 vn_sizeof_VkAttachmentStoreOp(const VkAttachmentStoreOp *val)
1772 {
1773 assert(sizeof(*val) == sizeof(int32_t));
1774 return vn_sizeof_int32_t((const int32_t *)val);
1775 }
1776
1777 static inline void
vn_encode_VkAttachmentStoreOp(struct vn_cs_encoder * enc,const VkAttachmentStoreOp * val)1778 vn_encode_VkAttachmentStoreOp(struct vn_cs_encoder *enc, const VkAttachmentStoreOp *val)
1779 {
1780 vn_encode_int32_t(enc, (const int32_t *)val);
1781 }
1782
1783 static inline void
vn_decode_VkAttachmentStoreOp(struct vn_cs_decoder * dec,VkAttachmentStoreOp * val)1784 vn_decode_VkAttachmentStoreOp(struct vn_cs_decoder *dec, VkAttachmentStoreOp *val)
1785 {
1786 vn_decode_int32_t(dec, (int32_t *)val);
1787 }
1788
1789 /* enum VkBlendFactor */
1790
1791 static inline size_t
vn_sizeof_VkBlendFactor(const VkBlendFactor * val)1792 vn_sizeof_VkBlendFactor(const VkBlendFactor *val)
1793 {
1794 assert(sizeof(*val) == sizeof(int32_t));
1795 return vn_sizeof_int32_t((const int32_t *)val);
1796 }
1797
1798 static inline void
vn_encode_VkBlendFactor(struct vn_cs_encoder * enc,const VkBlendFactor * val)1799 vn_encode_VkBlendFactor(struct vn_cs_encoder *enc, const VkBlendFactor *val)
1800 {
1801 vn_encode_int32_t(enc, (const int32_t *)val);
1802 }
1803
1804 static inline void
vn_decode_VkBlendFactor(struct vn_cs_decoder * dec,VkBlendFactor * val)1805 vn_decode_VkBlendFactor(struct vn_cs_decoder *dec, VkBlendFactor *val)
1806 {
1807 vn_decode_int32_t(dec, (int32_t *)val);
1808 }
1809
1810 /* enum VkBlendOp */
1811
1812 static inline size_t
vn_sizeof_VkBlendOp(const VkBlendOp * val)1813 vn_sizeof_VkBlendOp(const VkBlendOp *val)
1814 {
1815 assert(sizeof(*val) == sizeof(int32_t));
1816 return vn_sizeof_int32_t((const int32_t *)val);
1817 }
1818
1819 static inline void
vn_encode_VkBlendOp(struct vn_cs_encoder * enc,const VkBlendOp * val)1820 vn_encode_VkBlendOp(struct vn_cs_encoder *enc, const VkBlendOp *val)
1821 {
1822 vn_encode_int32_t(enc, (const int32_t *)val);
1823 }
1824
1825 static inline void
vn_decode_VkBlendOp(struct vn_cs_decoder * dec,VkBlendOp * val)1826 vn_decode_VkBlendOp(struct vn_cs_decoder *dec, VkBlendOp *val)
1827 {
1828 vn_decode_int32_t(dec, (int32_t *)val);
1829 }
1830
1831 /* enum VkBorderColor */
1832
1833 static inline size_t
vn_sizeof_VkBorderColor(const VkBorderColor * val)1834 vn_sizeof_VkBorderColor(const VkBorderColor *val)
1835 {
1836 assert(sizeof(*val) == sizeof(int32_t));
1837 return vn_sizeof_int32_t((const int32_t *)val);
1838 }
1839
1840 static inline void
vn_encode_VkBorderColor(struct vn_cs_encoder * enc,const VkBorderColor * val)1841 vn_encode_VkBorderColor(struct vn_cs_encoder *enc, const VkBorderColor *val)
1842 {
1843 vn_encode_int32_t(enc, (const int32_t *)val);
1844 }
1845
1846 static inline void
vn_decode_VkBorderColor(struct vn_cs_decoder * dec,VkBorderColor * val)1847 vn_decode_VkBorderColor(struct vn_cs_decoder *dec, VkBorderColor *val)
1848 {
1849 vn_decode_int32_t(dec, (int32_t *)val);
1850 }
1851
1852 /* enum VkPipelineCacheHeaderVersion */
1853
1854 static inline size_t
vn_sizeof_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion * val)1855 vn_sizeof_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion *val)
1856 {
1857 assert(sizeof(*val) == sizeof(int32_t));
1858 return vn_sizeof_int32_t((const int32_t *)val);
1859 }
1860
1861 static inline void
vn_encode_VkPipelineCacheHeaderVersion(struct vn_cs_encoder * enc,const VkPipelineCacheHeaderVersion * val)1862 vn_encode_VkPipelineCacheHeaderVersion(struct vn_cs_encoder *enc, const VkPipelineCacheHeaderVersion *val)
1863 {
1864 vn_encode_int32_t(enc, (const int32_t *)val);
1865 }
1866
1867 static inline void
vn_decode_VkPipelineCacheHeaderVersion(struct vn_cs_decoder * dec,VkPipelineCacheHeaderVersion * val)1868 vn_decode_VkPipelineCacheHeaderVersion(struct vn_cs_decoder *dec, VkPipelineCacheHeaderVersion *val)
1869 {
1870 vn_decode_int32_t(dec, (int32_t *)val);
1871 }
1872
1873 /* enum VkComponentSwizzle */
1874
1875 static inline size_t
vn_sizeof_VkComponentSwizzle(const VkComponentSwizzle * val)1876 vn_sizeof_VkComponentSwizzle(const VkComponentSwizzle *val)
1877 {
1878 assert(sizeof(*val) == sizeof(int32_t));
1879 return vn_sizeof_int32_t((const int32_t *)val);
1880 }
1881
1882 static inline void
vn_encode_VkComponentSwizzle(struct vn_cs_encoder * enc,const VkComponentSwizzle * val)1883 vn_encode_VkComponentSwizzle(struct vn_cs_encoder *enc, const VkComponentSwizzle *val)
1884 {
1885 vn_encode_int32_t(enc, (const int32_t *)val);
1886 }
1887
1888 static inline void
vn_decode_VkComponentSwizzle(struct vn_cs_decoder * dec,VkComponentSwizzle * val)1889 vn_decode_VkComponentSwizzle(struct vn_cs_decoder *dec, VkComponentSwizzle *val)
1890 {
1891 vn_decode_int32_t(dec, (int32_t *)val);
1892 }
1893
1894 /* enum VkCommandBufferLevel */
1895
1896 static inline size_t
vn_sizeof_VkCommandBufferLevel(const VkCommandBufferLevel * val)1897 vn_sizeof_VkCommandBufferLevel(const VkCommandBufferLevel *val)
1898 {
1899 assert(sizeof(*val) == sizeof(int32_t));
1900 return vn_sizeof_int32_t((const int32_t *)val);
1901 }
1902
1903 static inline void
vn_encode_VkCommandBufferLevel(struct vn_cs_encoder * enc,const VkCommandBufferLevel * val)1904 vn_encode_VkCommandBufferLevel(struct vn_cs_encoder *enc, const VkCommandBufferLevel *val)
1905 {
1906 vn_encode_int32_t(enc, (const int32_t *)val);
1907 }
1908
1909 static inline void
vn_decode_VkCommandBufferLevel(struct vn_cs_decoder * dec,VkCommandBufferLevel * val)1910 vn_decode_VkCommandBufferLevel(struct vn_cs_decoder *dec, VkCommandBufferLevel *val)
1911 {
1912 vn_decode_int32_t(dec, (int32_t *)val);
1913 }
1914
1915 /* enum VkCompareOp */
1916
1917 static inline size_t
vn_sizeof_VkCompareOp(const VkCompareOp * val)1918 vn_sizeof_VkCompareOp(const VkCompareOp *val)
1919 {
1920 assert(sizeof(*val) == sizeof(int32_t));
1921 return vn_sizeof_int32_t((const int32_t *)val);
1922 }
1923
1924 static inline void
vn_encode_VkCompareOp(struct vn_cs_encoder * enc,const VkCompareOp * val)1925 vn_encode_VkCompareOp(struct vn_cs_encoder *enc, const VkCompareOp *val)
1926 {
1927 vn_encode_int32_t(enc, (const int32_t *)val);
1928 }
1929
1930 static inline void
vn_decode_VkCompareOp(struct vn_cs_decoder * dec,VkCompareOp * val)1931 vn_decode_VkCompareOp(struct vn_cs_decoder *dec, VkCompareOp *val)
1932 {
1933 vn_decode_int32_t(dec, (int32_t *)val);
1934 }
1935
1936 /* enum VkDescriptorType */
1937
1938 static inline size_t
vn_sizeof_VkDescriptorType(const VkDescriptorType * val)1939 vn_sizeof_VkDescriptorType(const VkDescriptorType *val)
1940 {
1941 assert(sizeof(*val) == sizeof(int32_t));
1942 return vn_sizeof_int32_t((const int32_t *)val);
1943 }
1944
1945 static inline void
vn_encode_VkDescriptorType(struct vn_cs_encoder * enc,const VkDescriptorType * val)1946 vn_encode_VkDescriptorType(struct vn_cs_encoder *enc, const VkDescriptorType *val)
1947 {
1948 vn_encode_int32_t(enc, (const int32_t *)val);
1949 }
1950
1951 static inline void
vn_decode_VkDescriptorType(struct vn_cs_decoder * dec,VkDescriptorType * val)1952 vn_decode_VkDescriptorType(struct vn_cs_decoder *dec, VkDescriptorType *val)
1953 {
1954 vn_decode_int32_t(dec, (int32_t *)val);
1955 }
1956
1957 static inline size_t
vn_sizeof_VkDescriptorType_array(const VkDescriptorType * val,uint32_t count)1958 vn_sizeof_VkDescriptorType_array(const VkDescriptorType *val, uint32_t count)
1959 {
1960 return vn_sizeof_int32_t_array((const int32_t *)val, count);
1961 }
1962
1963 static inline void
vn_encode_VkDescriptorType_array(struct vn_cs_encoder * enc,const VkDescriptorType * val,uint32_t count)1964 vn_encode_VkDescriptorType_array(struct vn_cs_encoder *enc, const VkDescriptorType *val, uint32_t count)
1965 {
1966 vn_encode_int32_t_array(enc, (const int32_t *)val, count);
1967 }
1968
1969 static inline void
vn_decode_VkDescriptorType_array(struct vn_cs_decoder * dec,VkDescriptorType * val,uint32_t count)1970 vn_decode_VkDescriptorType_array(struct vn_cs_decoder *dec, VkDescriptorType *val, uint32_t count)
1971 {
1972 vn_decode_int32_t_array(dec, (int32_t *)val, count);
1973 }
1974
1975 /* enum VkDynamicState */
1976
1977 static inline size_t
vn_sizeof_VkDynamicState(const VkDynamicState * val)1978 vn_sizeof_VkDynamicState(const VkDynamicState *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_VkDynamicState(struct vn_cs_encoder * enc,const VkDynamicState * val)1985 vn_encode_VkDynamicState(struct vn_cs_encoder *enc, const VkDynamicState *val)
1986 {
1987 vn_encode_int32_t(enc, (const int32_t *)val);
1988 }
1989
1990 static inline void
vn_decode_VkDynamicState(struct vn_cs_decoder * dec,VkDynamicState * val)1991 vn_decode_VkDynamicState(struct vn_cs_decoder *dec, VkDynamicState *val)
1992 {
1993 vn_decode_int32_t(dec, (int32_t *)val);
1994 }
1995
1996 static inline size_t
vn_sizeof_VkDynamicState_array(const VkDynamicState * val,uint32_t count)1997 vn_sizeof_VkDynamicState_array(const VkDynamicState *val, uint32_t count)
1998 {
1999 return vn_sizeof_int32_t_array((const int32_t *)val, count);
2000 }
2001
2002 static inline void
vn_encode_VkDynamicState_array(struct vn_cs_encoder * enc,const VkDynamicState * val,uint32_t count)2003 vn_encode_VkDynamicState_array(struct vn_cs_encoder *enc, const VkDynamicState *val, uint32_t count)
2004 {
2005 vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2006 }
2007
2008 static inline void
vn_decode_VkDynamicState_array(struct vn_cs_decoder * dec,VkDynamicState * val,uint32_t count)2009 vn_decode_VkDynamicState_array(struct vn_cs_decoder *dec, VkDynamicState *val, uint32_t count)
2010 {
2011 vn_decode_int32_t_array(dec, (int32_t *)val, count);
2012 }
2013
2014 /* enum VkPolygonMode */
2015
2016 static inline size_t
vn_sizeof_VkPolygonMode(const VkPolygonMode * val)2017 vn_sizeof_VkPolygonMode(const VkPolygonMode *val)
2018 {
2019 assert(sizeof(*val) == sizeof(int32_t));
2020 return vn_sizeof_int32_t((const int32_t *)val);
2021 }
2022
2023 static inline void
vn_encode_VkPolygonMode(struct vn_cs_encoder * enc,const VkPolygonMode * val)2024 vn_encode_VkPolygonMode(struct vn_cs_encoder *enc, const VkPolygonMode *val)
2025 {
2026 vn_encode_int32_t(enc, (const int32_t *)val);
2027 }
2028
2029 static inline void
vn_decode_VkPolygonMode(struct vn_cs_decoder * dec,VkPolygonMode * val)2030 vn_decode_VkPolygonMode(struct vn_cs_decoder *dec, VkPolygonMode *val)
2031 {
2032 vn_decode_int32_t(dec, (int32_t *)val);
2033 }
2034
2035 /* enum VkFormat */
2036
2037 static inline size_t
vn_sizeof_VkFormat(const VkFormat * val)2038 vn_sizeof_VkFormat(const VkFormat *val)
2039 {
2040 assert(sizeof(*val) == sizeof(int32_t));
2041 return vn_sizeof_int32_t((const int32_t *)val);
2042 }
2043
2044 static inline void
vn_encode_VkFormat(struct vn_cs_encoder * enc,const VkFormat * val)2045 vn_encode_VkFormat(struct vn_cs_encoder *enc, const VkFormat *val)
2046 {
2047 vn_encode_int32_t(enc, (const int32_t *)val);
2048 }
2049
2050 static inline void
vn_decode_VkFormat(struct vn_cs_decoder * dec,VkFormat * val)2051 vn_decode_VkFormat(struct vn_cs_decoder *dec, VkFormat *val)
2052 {
2053 vn_decode_int32_t(dec, (int32_t *)val);
2054 }
2055
2056 static inline size_t
vn_sizeof_VkFormat_array(const VkFormat * val,uint32_t count)2057 vn_sizeof_VkFormat_array(const VkFormat *val, uint32_t count)
2058 {
2059 return vn_sizeof_int32_t_array((const int32_t *)val, count);
2060 }
2061
2062 static inline void
vn_encode_VkFormat_array(struct vn_cs_encoder * enc,const VkFormat * val,uint32_t count)2063 vn_encode_VkFormat_array(struct vn_cs_encoder *enc, const VkFormat *val, uint32_t count)
2064 {
2065 vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2066 }
2067
2068 static inline void
vn_decode_VkFormat_array(struct vn_cs_decoder * dec,VkFormat * val,uint32_t count)2069 vn_decode_VkFormat_array(struct vn_cs_decoder *dec, VkFormat *val, uint32_t count)
2070 {
2071 vn_decode_int32_t_array(dec, (int32_t *)val, count);
2072 }
2073
2074 /* enum VkFrontFace */
2075
2076 static inline size_t
vn_sizeof_VkFrontFace(const VkFrontFace * val)2077 vn_sizeof_VkFrontFace(const VkFrontFace *val)
2078 {
2079 assert(sizeof(*val) == sizeof(int32_t));
2080 return vn_sizeof_int32_t((const int32_t *)val);
2081 }
2082
2083 static inline void
vn_encode_VkFrontFace(struct vn_cs_encoder * enc,const VkFrontFace * val)2084 vn_encode_VkFrontFace(struct vn_cs_encoder *enc, const VkFrontFace *val)
2085 {
2086 vn_encode_int32_t(enc, (const int32_t *)val);
2087 }
2088
2089 static inline void
vn_decode_VkFrontFace(struct vn_cs_decoder * dec,VkFrontFace * val)2090 vn_decode_VkFrontFace(struct vn_cs_decoder *dec, VkFrontFace *val)
2091 {
2092 vn_decode_int32_t(dec, (int32_t *)val);
2093 }
2094
2095 /* enum VkImageLayout */
2096
2097 static inline size_t
vn_sizeof_VkImageLayout(const VkImageLayout * val)2098 vn_sizeof_VkImageLayout(const VkImageLayout *val)
2099 {
2100 assert(sizeof(*val) == sizeof(int32_t));
2101 return vn_sizeof_int32_t((const int32_t *)val);
2102 }
2103
2104 static inline void
vn_encode_VkImageLayout(struct vn_cs_encoder * enc,const VkImageLayout * val)2105 vn_encode_VkImageLayout(struct vn_cs_encoder *enc, const VkImageLayout *val)
2106 {
2107 vn_encode_int32_t(enc, (const int32_t *)val);
2108 }
2109
2110 static inline void
vn_decode_VkImageLayout(struct vn_cs_decoder * dec,VkImageLayout * val)2111 vn_decode_VkImageLayout(struct vn_cs_decoder *dec, VkImageLayout *val)
2112 {
2113 vn_decode_int32_t(dec, (int32_t *)val);
2114 }
2115
2116 /* enum VkImageTiling */
2117
2118 static inline size_t
vn_sizeof_VkImageTiling(const VkImageTiling * val)2119 vn_sizeof_VkImageTiling(const VkImageTiling *val)
2120 {
2121 assert(sizeof(*val) == sizeof(int32_t));
2122 return vn_sizeof_int32_t((const int32_t *)val);
2123 }
2124
2125 static inline void
vn_encode_VkImageTiling(struct vn_cs_encoder * enc,const VkImageTiling * val)2126 vn_encode_VkImageTiling(struct vn_cs_encoder *enc, const VkImageTiling *val)
2127 {
2128 vn_encode_int32_t(enc, (const int32_t *)val);
2129 }
2130
2131 static inline void
vn_decode_VkImageTiling(struct vn_cs_decoder * dec,VkImageTiling * val)2132 vn_decode_VkImageTiling(struct vn_cs_decoder *dec, VkImageTiling *val)
2133 {
2134 vn_decode_int32_t(dec, (int32_t *)val);
2135 }
2136
2137 /* enum VkImageType */
2138
2139 static inline size_t
vn_sizeof_VkImageType(const VkImageType * val)2140 vn_sizeof_VkImageType(const VkImageType *val)
2141 {
2142 assert(sizeof(*val) == sizeof(int32_t));
2143 return vn_sizeof_int32_t((const int32_t *)val);
2144 }
2145
2146 static inline void
vn_encode_VkImageType(struct vn_cs_encoder * enc,const VkImageType * val)2147 vn_encode_VkImageType(struct vn_cs_encoder *enc, const VkImageType *val)
2148 {
2149 vn_encode_int32_t(enc, (const int32_t *)val);
2150 }
2151
2152 static inline void
vn_decode_VkImageType(struct vn_cs_decoder * dec,VkImageType * val)2153 vn_decode_VkImageType(struct vn_cs_decoder *dec, VkImageType *val)
2154 {
2155 vn_decode_int32_t(dec, (int32_t *)val);
2156 }
2157
2158 /* enum VkImageViewType */
2159
2160 static inline size_t
vn_sizeof_VkImageViewType(const VkImageViewType * val)2161 vn_sizeof_VkImageViewType(const VkImageViewType *val)
2162 {
2163 assert(sizeof(*val) == sizeof(int32_t));
2164 return vn_sizeof_int32_t((const int32_t *)val);
2165 }
2166
2167 static inline void
vn_encode_VkImageViewType(struct vn_cs_encoder * enc,const VkImageViewType * val)2168 vn_encode_VkImageViewType(struct vn_cs_encoder *enc, const VkImageViewType *val)
2169 {
2170 vn_encode_int32_t(enc, (const int32_t *)val);
2171 }
2172
2173 static inline void
vn_decode_VkImageViewType(struct vn_cs_decoder * dec,VkImageViewType * val)2174 vn_decode_VkImageViewType(struct vn_cs_decoder *dec, VkImageViewType *val)
2175 {
2176 vn_decode_int32_t(dec, (int32_t *)val);
2177 }
2178
2179 /* enum VkSharingMode */
2180
2181 static inline size_t
vn_sizeof_VkSharingMode(const VkSharingMode * val)2182 vn_sizeof_VkSharingMode(const VkSharingMode *val)
2183 {
2184 assert(sizeof(*val) == sizeof(int32_t));
2185 return vn_sizeof_int32_t((const int32_t *)val);
2186 }
2187
2188 static inline void
vn_encode_VkSharingMode(struct vn_cs_encoder * enc,const VkSharingMode * val)2189 vn_encode_VkSharingMode(struct vn_cs_encoder *enc, const VkSharingMode *val)
2190 {
2191 vn_encode_int32_t(enc, (const int32_t *)val);
2192 }
2193
2194 static inline void
vn_decode_VkSharingMode(struct vn_cs_decoder * dec,VkSharingMode * val)2195 vn_decode_VkSharingMode(struct vn_cs_decoder *dec, VkSharingMode *val)
2196 {
2197 vn_decode_int32_t(dec, (int32_t *)val);
2198 }
2199
2200 /* enum VkIndexType */
2201
2202 static inline size_t
vn_sizeof_VkIndexType(const VkIndexType * val)2203 vn_sizeof_VkIndexType(const VkIndexType *val)
2204 {
2205 assert(sizeof(*val) == sizeof(int32_t));
2206 return vn_sizeof_int32_t((const int32_t *)val);
2207 }
2208
2209 static inline void
vn_encode_VkIndexType(struct vn_cs_encoder * enc,const VkIndexType * val)2210 vn_encode_VkIndexType(struct vn_cs_encoder *enc, const VkIndexType *val)
2211 {
2212 vn_encode_int32_t(enc, (const int32_t *)val);
2213 }
2214
2215 static inline void
vn_decode_VkIndexType(struct vn_cs_decoder * dec,VkIndexType * val)2216 vn_decode_VkIndexType(struct vn_cs_decoder *dec, VkIndexType *val)
2217 {
2218 vn_decode_int32_t(dec, (int32_t *)val);
2219 }
2220
2221 static inline size_t
vn_sizeof_VkIndexType_array(const VkIndexType * val,uint32_t count)2222 vn_sizeof_VkIndexType_array(const VkIndexType *val, uint32_t count)
2223 {
2224 return vn_sizeof_int32_t_array((const int32_t *)val, count);
2225 }
2226
2227 static inline void
vn_encode_VkIndexType_array(struct vn_cs_encoder * enc,const VkIndexType * val,uint32_t count)2228 vn_encode_VkIndexType_array(struct vn_cs_encoder *enc, const VkIndexType *val, uint32_t count)
2229 {
2230 vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2231 }
2232
2233 static inline void
vn_decode_VkIndexType_array(struct vn_cs_decoder * dec,VkIndexType * val,uint32_t count)2234 vn_decode_VkIndexType_array(struct vn_cs_decoder *dec, VkIndexType *val, uint32_t count)
2235 {
2236 vn_decode_int32_t_array(dec, (int32_t *)val, count);
2237 }
2238
2239 /* enum VkLogicOp */
2240
2241 static inline size_t
vn_sizeof_VkLogicOp(const VkLogicOp * val)2242 vn_sizeof_VkLogicOp(const VkLogicOp *val)
2243 {
2244 assert(sizeof(*val) == sizeof(int32_t));
2245 return vn_sizeof_int32_t((const int32_t *)val);
2246 }
2247
2248 static inline void
vn_encode_VkLogicOp(struct vn_cs_encoder * enc,const VkLogicOp * val)2249 vn_encode_VkLogicOp(struct vn_cs_encoder *enc, const VkLogicOp *val)
2250 {
2251 vn_encode_int32_t(enc, (const int32_t *)val);
2252 }
2253
2254 static inline void
vn_decode_VkLogicOp(struct vn_cs_decoder * dec,VkLogicOp * val)2255 vn_decode_VkLogicOp(struct vn_cs_decoder *dec, VkLogicOp *val)
2256 {
2257 vn_decode_int32_t(dec, (int32_t *)val);
2258 }
2259
2260 /* enum VkPhysicalDeviceType */
2261
2262 static inline size_t
vn_sizeof_VkPhysicalDeviceType(const VkPhysicalDeviceType * val)2263 vn_sizeof_VkPhysicalDeviceType(const VkPhysicalDeviceType *val)
2264 {
2265 assert(sizeof(*val) == sizeof(int32_t));
2266 return vn_sizeof_int32_t((const int32_t *)val);
2267 }
2268
2269 static inline void
vn_encode_VkPhysicalDeviceType(struct vn_cs_encoder * enc,const VkPhysicalDeviceType * val)2270 vn_encode_VkPhysicalDeviceType(struct vn_cs_encoder *enc, const VkPhysicalDeviceType *val)
2271 {
2272 vn_encode_int32_t(enc, (const int32_t *)val);
2273 }
2274
2275 static inline void
vn_decode_VkPhysicalDeviceType(struct vn_cs_decoder * dec,VkPhysicalDeviceType * val)2276 vn_decode_VkPhysicalDeviceType(struct vn_cs_decoder *dec, VkPhysicalDeviceType *val)
2277 {
2278 vn_decode_int32_t(dec, (int32_t *)val);
2279 }
2280
2281 /* enum VkPipelineBindPoint */
2282
2283 static inline size_t
vn_sizeof_VkPipelineBindPoint(const VkPipelineBindPoint * val)2284 vn_sizeof_VkPipelineBindPoint(const VkPipelineBindPoint *val)
2285 {
2286 assert(sizeof(*val) == sizeof(int32_t));
2287 return vn_sizeof_int32_t((const int32_t *)val);
2288 }
2289
2290 static inline void
vn_encode_VkPipelineBindPoint(struct vn_cs_encoder * enc,const VkPipelineBindPoint * val)2291 vn_encode_VkPipelineBindPoint(struct vn_cs_encoder *enc, const VkPipelineBindPoint *val)
2292 {
2293 vn_encode_int32_t(enc, (const int32_t *)val);
2294 }
2295
2296 static inline void
vn_decode_VkPipelineBindPoint(struct vn_cs_decoder * dec,VkPipelineBindPoint * val)2297 vn_decode_VkPipelineBindPoint(struct vn_cs_decoder *dec, VkPipelineBindPoint *val)
2298 {
2299 vn_decode_int32_t(dec, (int32_t *)val);
2300 }
2301
2302 /* enum VkPrimitiveTopology */
2303
2304 static inline size_t
vn_sizeof_VkPrimitiveTopology(const VkPrimitiveTopology * val)2305 vn_sizeof_VkPrimitiveTopology(const VkPrimitiveTopology *val)
2306 {
2307 assert(sizeof(*val) == sizeof(int32_t));
2308 return vn_sizeof_int32_t((const int32_t *)val);
2309 }
2310
2311 static inline void
vn_encode_VkPrimitiveTopology(struct vn_cs_encoder * enc,const VkPrimitiveTopology * val)2312 vn_encode_VkPrimitiveTopology(struct vn_cs_encoder *enc, const VkPrimitiveTopology *val)
2313 {
2314 vn_encode_int32_t(enc, (const int32_t *)val);
2315 }
2316
2317 static inline void
vn_decode_VkPrimitiveTopology(struct vn_cs_decoder * dec,VkPrimitiveTopology * val)2318 vn_decode_VkPrimitiveTopology(struct vn_cs_decoder *dec, VkPrimitiveTopology *val)
2319 {
2320 vn_decode_int32_t(dec, (int32_t *)val);
2321 }
2322
2323 /* enum VkQueryType */
2324
2325 static inline size_t
vn_sizeof_VkQueryType(const VkQueryType * val)2326 vn_sizeof_VkQueryType(const VkQueryType *val)
2327 {
2328 assert(sizeof(*val) == sizeof(int32_t));
2329 return vn_sizeof_int32_t((const int32_t *)val);
2330 }
2331
2332 static inline void
vn_encode_VkQueryType(struct vn_cs_encoder * enc,const VkQueryType * val)2333 vn_encode_VkQueryType(struct vn_cs_encoder *enc, const VkQueryType *val)
2334 {
2335 vn_encode_int32_t(enc, (const int32_t *)val);
2336 }
2337
2338 static inline void
vn_decode_VkQueryType(struct vn_cs_decoder * dec,VkQueryType * val)2339 vn_decode_VkQueryType(struct vn_cs_decoder *dec, VkQueryType *val)
2340 {
2341 vn_decode_int32_t(dec, (int32_t *)val);
2342 }
2343
2344 /* enum VkSubpassContents */
2345
2346 static inline size_t
vn_sizeof_VkSubpassContents(const VkSubpassContents * val)2347 vn_sizeof_VkSubpassContents(const VkSubpassContents *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_VkSubpassContents(struct vn_cs_encoder * enc,const VkSubpassContents * val)2354 vn_encode_VkSubpassContents(struct vn_cs_encoder *enc, const VkSubpassContents *val)
2355 {
2356 vn_encode_int32_t(enc, (const int32_t *)val);
2357 }
2358
2359 static inline void
vn_decode_VkSubpassContents(struct vn_cs_decoder * dec,VkSubpassContents * val)2360 vn_decode_VkSubpassContents(struct vn_cs_decoder *dec, VkSubpassContents *val)
2361 {
2362 vn_decode_int32_t(dec, (int32_t *)val);
2363 }
2364
2365 /* enum VkResult */
2366
2367 static inline size_t
vn_sizeof_VkResult(const VkResult * val)2368 vn_sizeof_VkResult(const VkResult *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_VkResult(struct vn_cs_encoder * enc,const VkResult * val)2375 vn_encode_VkResult(struct vn_cs_encoder *enc, const VkResult *val)
2376 {
2377 vn_encode_int32_t(enc, (const int32_t *)val);
2378 }
2379
2380 static inline void
vn_decode_VkResult(struct vn_cs_decoder * dec,VkResult * val)2381 vn_decode_VkResult(struct vn_cs_decoder *dec, VkResult *val)
2382 {
2383 vn_decode_int32_t(dec, (int32_t *)val);
2384 }
2385
2386 static inline size_t
vn_sizeof_VkResult_array(const VkResult * val,uint32_t count)2387 vn_sizeof_VkResult_array(const VkResult *val, uint32_t count)
2388 {
2389 return vn_sizeof_int32_t_array((const int32_t *)val, count);
2390 }
2391
2392 static inline void
vn_encode_VkResult_array(struct vn_cs_encoder * enc,const VkResult * val,uint32_t count)2393 vn_encode_VkResult_array(struct vn_cs_encoder *enc, const VkResult *val, uint32_t count)
2394 {
2395 vn_encode_int32_t_array(enc, (const int32_t *)val, count);
2396 }
2397
2398 static inline void
vn_decode_VkResult_array(struct vn_cs_decoder * dec,VkResult * val,uint32_t count)2399 vn_decode_VkResult_array(struct vn_cs_decoder *dec, VkResult *val, uint32_t count)
2400 {
2401 vn_decode_int32_t_array(dec, (int32_t *)val, count);
2402 }
2403
2404 /* enum VkStencilOp */
2405
2406 static inline size_t
vn_sizeof_VkStencilOp(const VkStencilOp * val)2407 vn_sizeof_VkStencilOp(const VkStencilOp *val)
2408 {
2409 assert(sizeof(*val) == sizeof(int32_t));
2410 return vn_sizeof_int32_t((const int32_t *)val);
2411 }
2412
2413 static inline void
vn_encode_VkStencilOp(struct vn_cs_encoder * enc,const VkStencilOp * val)2414 vn_encode_VkStencilOp(struct vn_cs_encoder *enc, const VkStencilOp *val)
2415 {
2416 vn_encode_int32_t(enc, (const int32_t *)val);
2417 }
2418
2419 static inline void
vn_decode_VkStencilOp(struct vn_cs_decoder * dec,VkStencilOp * val)2420 vn_decode_VkStencilOp(struct vn_cs_decoder *dec, VkStencilOp *val)
2421 {
2422 vn_decode_int32_t(dec, (int32_t *)val);
2423 }
2424
2425 /* enum VkSystemAllocationScope */
2426
2427 static inline size_t
vn_sizeof_VkSystemAllocationScope(const VkSystemAllocationScope * val)2428 vn_sizeof_VkSystemAllocationScope(const VkSystemAllocationScope *val)
2429 {
2430 assert(sizeof(*val) == sizeof(int32_t));
2431 return vn_sizeof_int32_t((const int32_t *)val);
2432 }
2433
2434 static inline void
vn_encode_VkSystemAllocationScope(struct vn_cs_encoder * enc,const VkSystemAllocationScope * val)2435 vn_encode_VkSystemAllocationScope(struct vn_cs_encoder *enc, const VkSystemAllocationScope *val)
2436 {
2437 vn_encode_int32_t(enc, (const int32_t *)val);
2438 }
2439
2440 static inline void
vn_decode_VkSystemAllocationScope(struct vn_cs_decoder * dec,VkSystemAllocationScope * val)2441 vn_decode_VkSystemAllocationScope(struct vn_cs_decoder *dec, VkSystemAllocationScope *val)
2442 {
2443 vn_decode_int32_t(dec, (int32_t *)val);
2444 }
2445
2446 /* enum VkInternalAllocationType */
2447
2448 static inline size_t
vn_sizeof_VkInternalAllocationType(const VkInternalAllocationType * val)2449 vn_sizeof_VkInternalAllocationType(const VkInternalAllocationType *val)
2450 {
2451 assert(sizeof(*val) == sizeof(int32_t));
2452 return vn_sizeof_int32_t((const int32_t *)val);
2453 }
2454
2455 static inline void
vn_encode_VkInternalAllocationType(struct vn_cs_encoder * enc,const VkInternalAllocationType * val)2456 vn_encode_VkInternalAllocationType(struct vn_cs_encoder *enc, const VkInternalAllocationType *val)
2457 {
2458 vn_encode_int32_t(enc, (const int32_t *)val);
2459 }
2460
2461 static inline void
vn_decode_VkInternalAllocationType(struct vn_cs_decoder * dec,VkInternalAllocationType * val)2462 vn_decode_VkInternalAllocationType(struct vn_cs_decoder *dec, VkInternalAllocationType *val)
2463 {
2464 vn_decode_int32_t(dec, (int32_t *)val);
2465 }
2466
2467 /* enum VkSamplerAddressMode */
2468
2469 static inline size_t
vn_sizeof_VkSamplerAddressMode(const VkSamplerAddressMode * val)2470 vn_sizeof_VkSamplerAddressMode(const VkSamplerAddressMode *val)
2471 {
2472 assert(sizeof(*val) == sizeof(int32_t));
2473 return vn_sizeof_int32_t((const int32_t *)val);
2474 }
2475
2476 static inline void
vn_encode_VkSamplerAddressMode(struct vn_cs_encoder * enc,const VkSamplerAddressMode * val)2477 vn_encode_VkSamplerAddressMode(struct vn_cs_encoder *enc, const VkSamplerAddressMode *val)
2478 {
2479 vn_encode_int32_t(enc, (const int32_t *)val);
2480 }
2481
2482 static inline void
vn_decode_VkSamplerAddressMode(struct vn_cs_decoder * dec,VkSamplerAddressMode * val)2483 vn_decode_VkSamplerAddressMode(struct vn_cs_decoder *dec, VkSamplerAddressMode *val)
2484 {
2485 vn_decode_int32_t(dec, (int32_t *)val);
2486 }
2487
2488 /* enum VkFilter */
2489
2490 static inline size_t
vn_sizeof_VkFilter(const VkFilter * val)2491 vn_sizeof_VkFilter(const VkFilter *val)
2492 {
2493 assert(sizeof(*val) == sizeof(int32_t));
2494 return vn_sizeof_int32_t((const int32_t *)val);
2495 }
2496
2497 static inline void
vn_encode_VkFilter(struct vn_cs_encoder * enc,const VkFilter * val)2498 vn_encode_VkFilter(struct vn_cs_encoder *enc, const VkFilter *val)
2499 {
2500 vn_encode_int32_t(enc, (const int32_t *)val);
2501 }
2502
2503 static inline void
vn_decode_VkFilter(struct vn_cs_decoder * dec,VkFilter * val)2504 vn_decode_VkFilter(struct vn_cs_decoder *dec, VkFilter *val)
2505 {
2506 vn_decode_int32_t(dec, (int32_t *)val);
2507 }
2508
2509 /* enum VkSamplerMipmapMode */
2510
2511 static inline size_t
vn_sizeof_VkSamplerMipmapMode(const VkSamplerMipmapMode * val)2512 vn_sizeof_VkSamplerMipmapMode(const VkSamplerMipmapMode *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_VkSamplerMipmapMode(struct vn_cs_encoder * enc,const VkSamplerMipmapMode * val)2519 vn_encode_VkSamplerMipmapMode(struct vn_cs_encoder *enc, const VkSamplerMipmapMode *val)
2520 {
2521 vn_encode_int32_t(enc, (const int32_t *)val);
2522 }
2523
2524 static inline void
vn_decode_VkSamplerMipmapMode(struct vn_cs_decoder * dec,VkSamplerMipmapMode * val)2525 vn_decode_VkSamplerMipmapMode(struct vn_cs_decoder *dec, VkSamplerMipmapMode *val)
2526 {
2527 vn_decode_int32_t(dec, (int32_t *)val);
2528 }
2529
2530 /* enum VkVertexInputRate */
2531
2532 static inline size_t
vn_sizeof_VkVertexInputRate(const VkVertexInputRate * val)2533 vn_sizeof_VkVertexInputRate(const VkVertexInputRate *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_VkVertexInputRate(struct vn_cs_encoder * enc,const VkVertexInputRate * val)2540 vn_encode_VkVertexInputRate(struct vn_cs_encoder *enc, const VkVertexInputRate *val)
2541 {
2542 vn_encode_int32_t(enc, (const int32_t *)val);
2543 }
2544
2545 static inline void
vn_decode_VkVertexInputRate(struct vn_cs_decoder * dec,VkVertexInputRate * val)2546 vn_decode_VkVertexInputRate(struct vn_cs_decoder *dec, VkVertexInputRate *val)
2547 {
2548 vn_decode_int32_t(dec, (int32_t *)val);
2549 }
2550
2551 /* enum VkObjectType */
2552
2553 static inline size_t
vn_sizeof_VkObjectType(const VkObjectType * val)2554 vn_sizeof_VkObjectType(const VkObjectType *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_VkObjectType(struct vn_cs_encoder * enc,const VkObjectType * val)2561 vn_encode_VkObjectType(struct vn_cs_encoder *enc, const VkObjectType *val)
2562 {
2563 vn_encode_int32_t(enc, (const int32_t *)val);
2564 }
2565
2566 static inline void
vn_decode_VkObjectType(struct vn_cs_decoder * dec,VkObjectType * val)2567 vn_decode_VkObjectType(struct vn_cs_decoder *dec, VkObjectType *val)
2568 {
2569 vn_decode_int32_t(dec, (int32_t *)val);
2570 }
2571
2572 /* enum VkDescriptorUpdateTemplateType */
2573
2574 static inline size_t
vn_sizeof_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType * val)2575 vn_sizeof_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType *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_VkDescriptorUpdateTemplateType(struct vn_cs_encoder * enc,const VkDescriptorUpdateTemplateType * val)2582 vn_encode_VkDescriptorUpdateTemplateType(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateType *val)
2583 {
2584 vn_encode_int32_t(enc, (const int32_t *)val);
2585 }
2586
2587 static inline void
vn_decode_VkDescriptorUpdateTemplateType(struct vn_cs_decoder * dec,VkDescriptorUpdateTemplateType * val)2588 vn_decode_VkDescriptorUpdateTemplateType(struct vn_cs_decoder *dec, VkDescriptorUpdateTemplateType *val)
2589 {
2590 vn_decode_int32_t(dec, (int32_t *)val);
2591 }
2592
2593 /* enum VkPointClippingBehavior */
2594
2595 static inline size_t
vn_sizeof_VkPointClippingBehavior(const VkPointClippingBehavior * val)2596 vn_sizeof_VkPointClippingBehavior(const VkPointClippingBehavior *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_VkPointClippingBehavior(struct vn_cs_encoder * enc,const VkPointClippingBehavior * val)2603 vn_encode_VkPointClippingBehavior(struct vn_cs_encoder *enc, const VkPointClippingBehavior *val)
2604 {
2605 vn_encode_int32_t(enc, (const int32_t *)val);
2606 }
2607
2608 static inline void
vn_decode_VkPointClippingBehavior(struct vn_cs_decoder * dec,VkPointClippingBehavior * val)2609 vn_decode_VkPointClippingBehavior(struct vn_cs_decoder *dec, VkPointClippingBehavior *val)
2610 {
2611 vn_decode_int32_t(dec, (int32_t *)val);
2612 }
2613
2614 /* enum VkSemaphoreType */
2615
2616 static inline size_t
vn_sizeof_VkSemaphoreType(const VkSemaphoreType * val)2617 vn_sizeof_VkSemaphoreType(const VkSemaphoreType *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_VkSemaphoreType(struct vn_cs_encoder * enc,const VkSemaphoreType * val)2624 vn_encode_VkSemaphoreType(struct vn_cs_encoder *enc, const VkSemaphoreType *val)
2625 {
2626 vn_encode_int32_t(enc, (const int32_t *)val);
2627 }
2628
2629 static inline void
vn_decode_VkSemaphoreType(struct vn_cs_decoder * dec,VkSemaphoreType * val)2630 vn_decode_VkSemaphoreType(struct vn_cs_decoder *dec, VkSemaphoreType *val)
2631 {
2632 vn_decode_int32_t(dec, (int32_t *)val);
2633 }
2634
2635 /* enum VkTessellationDomainOrigin */
2636
2637 static inline size_t
vn_sizeof_VkTessellationDomainOrigin(const VkTessellationDomainOrigin * val)2638 vn_sizeof_VkTessellationDomainOrigin(const VkTessellationDomainOrigin *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_VkTessellationDomainOrigin(struct vn_cs_encoder * enc,const VkTessellationDomainOrigin * val)2645 vn_encode_VkTessellationDomainOrigin(struct vn_cs_encoder *enc, const VkTessellationDomainOrigin *val)
2646 {
2647 vn_encode_int32_t(enc, (const int32_t *)val);
2648 }
2649
2650 static inline void
vn_decode_VkTessellationDomainOrigin(struct vn_cs_decoder * dec,VkTessellationDomainOrigin * val)2651 vn_decode_VkTessellationDomainOrigin(struct vn_cs_decoder *dec, VkTessellationDomainOrigin *val)
2652 {
2653 vn_decode_int32_t(dec, (int32_t *)val);
2654 }
2655
2656 /* enum VkSamplerYcbcrModelConversion */
2657
2658 static inline size_t
vn_sizeof_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion * val)2659 vn_sizeof_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion *val)
2660 {
2661 assert(sizeof(*val) == sizeof(int32_t));
2662 return vn_sizeof_int32_t((const int32_t *)val);
2663 }
2664
2665 static inline void
vn_encode_VkSamplerYcbcrModelConversion(struct vn_cs_encoder * enc,const VkSamplerYcbcrModelConversion * val)2666 vn_encode_VkSamplerYcbcrModelConversion(struct vn_cs_encoder *enc, const VkSamplerYcbcrModelConversion *val)
2667 {
2668 vn_encode_int32_t(enc, (const int32_t *)val);
2669 }
2670
2671 static inline void
vn_decode_VkSamplerYcbcrModelConversion(struct vn_cs_decoder * dec,VkSamplerYcbcrModelConversion * val)2672 vn_decode_VkSamplerYcbcrModelConversion(struct vn_cs_decoder *dec, VkSamplerYcbcrModelConversion *val)
2673 {
2674 vn_decode_int32_t(dec, (int32_t *)val);
2675 }
2676
2677 /* enum VkSamplerYcbcrRange */
2678
2679 static inline size_t
vn_sizeof_VkSamplerYcbcrRange(const VkSamplerYcbcrRange * val)2680 vn_sizeof_VkSamplerYcbcrRange(const VkSamplerYcbcrRange *val)
2681 {
2682 assert(sizeof(*val) == sizeof(int32_t));
2683 return vn_sizeof_int32_t((const int32_t *)val);
2684 }
2685
2686 static inline void
vn_encode_VkSamplerYcbcrRange(struct vn_cs_encoder * enc,const VkSamplerYcbcrRange * val)2687 vn_encode_VkSamplerYcbcrRange(struct vn_cs_encoder *enc, const VkSamplerYcbcrRange *val)
2688 {
2689 vn_encode_int32_t(enc, (const int32_t *)val);
2690 }
2691
2692 static inline void
vn_decode_VkSamplerYcbcrRange(struct vn_cs_decoder * dec,VkSamplerYcbcrRange * val)2693 vn_decode_VkSamplerYcbcrRange(struct vn_cs_decoder *dec, VkSamplerYcbcrRange *val)
2694 {
2695 vn_decode_int32_t(dec, (int32_t *)val);
2696 }
2697
2698 /* enum VkChromaLocation */
2699
2700 static inline size_t
vn_sizeof_VkChromaLocation(const VkChromaLocation * val)2701 vn_sizeof_VkChromaLocation(const VkChromaLocation *val)
2702 {
2703 assert(sizeof(*val) == sizeof(int32_t));
2704 return vn_sizeof_int32_t((const int32_t *)val);
2705 }
2706
2707 static inline void
vn_encode_VkChromaLocation(struct vn_cs_encoder * enc,const VkChromaLocation * val)2708 vn_encode_VkChromaLocation(struct vn_cs_encoder *enc, const VkChromaLocation *val)
2709 {
2710 vn_encode_int32_t(enc, (const int32_t *)val);
2711 }
2712
2713 static inline void
vn_decode_VkChromaLocation(struct vn_cs_decoder * dec,VkChromaLocation * val)2714 vn_decode_VkChromaLocation(struct vn_cs_decoder *dec, VkChromaLocation *val)
2715 {
2716 vn_decode_int32_t(dec, (int32_t *)val);
2717 }
2718
2719 /* enum VkSamplerReductionMode */
2720
2721 static inline size_t
vn_sizeof_VkSamplerReductionMode(const VkSamplerReductionMode * val)2722 vn_sizeof_VkSamplerReductionMode(const VkSamplerReductionMode *val)
2723 {
2724 assert(sizeof(*val) == sizeof(int32_t));
2725 return vn_sizeof_int32_t((const int32_t *)val);
2726 }
2727
2728 static inline void
vn_encode_VkSamplerReductionMode(struct vn_cs_encoder * enc,const VkSamplerReductionMode * val)2729 vn_encode_VkSamplerReductionMode(struct vn_cs_encoder *enc, const VkSamplerReductionMode *val)
2730 {
2731 vn_encode_int32_t(enc, (const int32_t *)val);
2732 }
2733
2734 static inline void
vn_decode_VkSamplerReductionMode(struct vn_cs_decoder * dec,VkSamplerReductionMode * val)2735 vn_decode_VkSamplerReductionMode(struct vn_cs_decoder *dec, VkSamplerReductionMode *val)
2736 {
2737 vn_decode_int32_t(dec, (int32_t *)val);
2738 }
2739
2740 /* enum VkShaderFloatControlsIndependence */
2741
2742 static inline size_t
vn_sizeof_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence * val)2743 vn_sizeof_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence *val)
2744 {
2745 assert(sizeof(*val) == sizeof(int32_t));
2746 return vn_sizeof_int32_t((const int32_t *)val);
2747 }
2748
2749 static inline void
vn_encode_VkShaderFloatControlsIndependence(struct vn_cs_encoder * enc,const VkShaderFloatControlsIndependence * val)2750 vn_encode_VkShaderFloatControlsIndependence(struct vn_cs_encoder *enc, const VkShaderFloatControlsIndependence *val)
2751 {
2752 vn_encode_int32_t(enc, (const int32_t *)val);
2753 }
2754
2755 static inline void
vn_decode_VkShaderFloatControlsIndependence(struct vn_cs_decoder * dec,VkShaderFloatControlsIndependence * val)2756 vn_decode_VkShaderFloatControlsIndependence(struct vn_cs_decoder *dec, VkShaderFloatControlsIndependence *val)
2757 {
2758 vn_decode_int32_t(dec, (int32_t *)val);
2759 }
2760
2761 /* enum VkVendorId */
2762
2763 static inline size_t
vn_sizeof_VkVendorId(const VkVendorId * val)2764 vn_sizeof_VkVendorId(const VkVendorId *val)
2765 {
2766 assert(sizeof(*val) == sizeof(int32_t));
2767 return vn_sizeof_int32_t((const int32_t *)val);
2768 }
2769
2770 static inline void
vn_encode_VkVendorId(struct vn_cs_encoder * enc,const VkVendorId * val)2771 vn_encode_VkVendorId(struct vn_cs_encoder *enc, const VkVendorId *val)
2772 {
2773 vn_encode_int32_t(enc, (const int32_t *)val);
2774 }
2775
2776 static inline void
vn_decode_VkVendorId(struct vn_cs_decoder * dec,VkVendorId * val)2777 vn_decode_VkVendorId(struct vn_cs_decoder *dec, VkVendorId *val)
2778 {
2779 vn_decode_int32_t(dec, (int32_t *)val);
2780 }
2781
2782 /* enum VkDriverId */
2783
2784 static inline size_t
vn_sizeof_VkDriverId(const VkDriverId * val)2785 vn_sizeof_VkDriverId(const VkDriverId *val)
2786 {
2787 assert(sizeof(*val) == sizeof(int32_t));
2788 return vn_sizeof_int32_t((const int32_t *)val);
2789 }
2790
2791 static inline void
vn_encode_VkDriverId(struct vn_cs_encoder * enc,const VkDriverId * val)2792 vn_encode_VkDriverId(struct vn_cs_encoder *enc, const VkDriverId *val)
2793 {
2794 vn_encode_int32_t(enc, (const int32_t *)val);
2795 }
2796
2797 static inline void
vn_decode_VkDriverId(struct vn_cs_decoder * dec,VkDriverId * val)2798 vn_decode_VkDriverId(struct vn_cs_decoder *dec, VkDriverId *val)
2799 {
2800 vn_decode_int32_t(dec, (int32_t *)val);
2801 }
2802
2803 /* enum VkCommandFlagBitsEXT */
2804
2805 static inline size_t
vn_sizeof_VkCommandFlagBitsEXT(const VkCommandFlagBitsEXT * val)2806 vn_sizeof_VkCommandFlagBitsEXT(const VkCommandFlagBitsEXT *val)
2807 {
2808 assert(sizeof(*val) == sizeof(int32_t));
2809 return vn_sizeof_int32_t((const int32_t *)val);
2810 }
2811
2812 static inline void
vn_encode_VkCommandFlagBitsEXT(struct vn_cs_encoder * enc,const VkCommandFlagBitsEXT * val)2813 vn_encode_VkCommandFlagBitsEXT(struct vn_cs_encoder *enc, const VkCommandFlagBitsEXT *val)
2814 {
2815 vn_encode_int32_t(enc, (const int32_t *)val);
2816 }
2817
2818 static inline void
vn_decode_VkCommandFlagBitsEXT(struct vn_cs_decoder * dec,VkCommandFlagBitsEXT * val)2819 vn_decode_VkCommandFlagBitsEXT(struct vn_cs_decoder *dec, VkCommandFlagBitsEXT *val)
2820 {
2821 vn_decode_int32_t(dec, (int32_t *)val);
2822 }
2823
2824 /* enum VkCommandTypeEXT */
2825
2826 static inline size_t
vn_sizeof_VkCommandTypeEXT(const VkCommandTypeEXT * val)2827 vn_sizeof_VkCommandTypeEXT(const VkCommandTypeEXT *val)
2828 {
2829 assert(sizeof(*val) == sizeof(int32_t));
2830 return vn_sizeof_int32_t((const int32_t *)val);
2831 }
2832
2833 static inline void
vn_encode_VkCommandTypeEXT(struct vn_cs_encoder * enc,const VkCommandTypeEXT * val)2834 vn_encode_VkCommandTypeEXT(struct vn_cs_encoder *enc, const VkCommandTypeEXT *val)
2835 {
2836 vn_encode_int32_t(enc, (const int32_t *)val);
2837 }
2838
2839 static inline void
vn_decode_VkCommandTypeEXT(struct vn_cs_decoder * dec,VkCommandTypeEXT * val)2840 vn_decode_VkCommandTypeEXT(struct vn_cs_decoder *dec, VkCommandTypeEXT *val)
2841 {
2842 vn_decode_int32_t(dec, (int32_t *)val);
2843 }
2844
2845 #endif /* VN_PROTOCOL_DRIVER_TYPES_H */
2846