1 /* This file is generated by venus-protocol. See vn_protocol_renderer.h. */
2
3 /*
4 * Copyright 2020 Google LLC
5 * SPDX-License-Identifier: MIT
6 */
7
8 #ifndef VN_PROTOCOL_RENDERER_COMMAND_BUFFER_H
9 #define VN_PROTOCOL_RENDERER_COMMAND_BUFFER_H
10
11 #include "vn_protocol_renderer_structs.h"
12
13 #pragma GCC diagnostic push
14 #pragma GCC diagnostic ignored "-Wpointer-arith"
15 #pragma GCC diagnostic ignored "-Wunused-parameter"
16
17 /*
18 * These structs/unions/commands are not included
19 *
20 * vkCmdPushDescriptorSetWithTemplateKHR
21 */
22
23 /* struct VkCommandBufferAllocateInfo chain */
24
25 static inline void *
vn_decode_VkCommandBufferAllocateInfo_pnext_temp(struct vn_cs_decoder * dec)26 vn_decode_VkCommandBufferAllocateInfo_pnext_temp(struct vn_cs_decoder *dec)
27 {
28 /* no known/supported struct */
29 if (vn_decode_simple_pointer(dec))
30 vn_cs_decoder_set_fatal(dec);
31 return NULL;
32 }
33
34 static inline void
vn_decode_VkCommandBufferAllocateInfo_self_temp(struct vn_cs_decoder * dec,VkCommandBufferAllocateInfo * val)35 vn_decode_VkCommandBufferAllocateInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferAllocateInfo *val)
36 {
37 /* skip val->{sType,pNext} */
38 vn_decode_VkCommandPool_lookup(dec, &val->commandPool);
39 vn_decode_VkCommandBufferLevel(dec, &val->level);
40 vn_decode_uint32_t(dec, &val->commandBufferCount);
41 }
42
43 static inline void
vn_decode_VkCommandBufferAllocateInfo_temp(struct vn_cs_decoder * dec,VkCommandBufferAllocateInfo * val)44 vn_decode_VkCommandBufferAllocateInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferAllocateInfo *val)
45 {
46 VkStructureType stype;
47 vn_decode_VkStructureType(dec, &stype);
48 if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)
49 vn_cs_decoder_set_fatal(dec);
50
51 val->sType = stype;
52 val->pNext = vn_decode_VkCommandBufferAllocateInfo_pnext_temp(dec);
53 vn_decode_VkCommandBufferAllocateInfo_self_temp(dec, val);
54 }
55
56 static inline void
vn_replace_VkCommandBufferAllocateInfo_handle_self(VkCommandBufferAllocateInfo * val)57 vn_replace_VkCommandBufferAllocateInfo_handle_self(VkCommandBufferAllocateInfo *val)
58 {
59 /* skip val->sType */
60 /* skip val->pNext */
61 vn_replace_VkCommandPool_handle(&val->commandPool);
62 /* skip val->level */
63 /* skip val->commandBufferCount */
64 }
65
66 static inline void
vn_replace_VkCommandBufferAllocateInfo_handle(VkCommandBufferAllocateInfo * val)67 vn_replace_VkCommandBufferAllocateInfo_handle(VkCommandBufferAllocateInfo *val)
68 {
69 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
70
71 do {
72 switch ((int32_t)pnext->sType) {
73 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
74 vn_replace_VkCommandBufferAllocateInfo_handle_self((VkCommandBufferAllocateInfo *)pnext);
75 break;
76 default:
77 /* ignore unknown/unsupported struct */
78 break;
79 }
80 pnext = pnext->pNext;
81 } while (pnext);
82 }
83
84 /* struct VkCommandBufferInheritanceConditionalRenderingInfoEXT chain */
85
86 static inline void *
vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_pnext_temp(struct vn_cs_decoder * dec)87 vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
88 {
89 /* no known/supported struct */
90 if (vn_decode_simple_pointer(dec))
91 vn_cs_decoder_set_fatal(dec);
92 return NULL;
93 }
94
95 static inline void
vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_self_temp(struct vn_cs_decoder * dec,VkCommandBufferInheritanceConditionalRenderingInfoEXT * val)96 vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_self_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceConditionalRenderingInfoEXT *val)
97 {
98 /* skip val->{sType,pNext} */
99 vn_decode_VkBool32(dec, &val->conditionalRenderingEnable);
100 }
101
102 static inline void
vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_temp(struct vn_cs_decoder * dec,VkCommandBufferInheritanceConditionalRenderingInfoEXT * val)103 vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceConditionalRenderingInfoEXT *val)
104 {
105 VkStructureType stype;
106 vn_decode_VkStructureType(dec, &stype);
107 if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT)
108 vn_cs_decoder_set_fatal(dec);
109
110 val->sType = stype;
111 val->pNext = vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_pnext_temp(dec);
112 vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_self_temp(dec, val);
113 }
114
115 static inline void
vn_replace_VkCommandBufferInheritanceConditionalRenderingInfoEXT_handle_self(VkCommandBufferInheritanceConditionalRenderingInfoEXT * val)116 vn_replace_VkCommandBufferInheritanceConditionalRenderingInfoEXT_handle_self(VkCommandBufferInheritanceConditionalRenderingInfoEXT *val)
117 {
118 /* skip val->sType */
119 /* skip val->pNext */
120 /* skip val->conditionalRenderingEnable */
121 }
122
123 static inline void
vn_replace_VkCommandBufferInheritanceConditionalRenderingInfoEXT_handle(VkCommandBufferInheritanceConditionalRenderingInfoEXT * val)124 vn_replace_VkCommandBufferInheritanceConditionalRenderingInfoEXT_handle(VkCommandBufferInheritanceConditionalRenderingInfoEXT *val)
125 {
126 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
127
128 do {
129 switch ((int32_t)pnext->sType) {
130 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
131 vn_replace_VkCommandBufferInheritanceConditionalRenderingInfoEXT_handle_self((VkCommandBufferInheritanceConditionalRenderingInfoEXT *)pnext);
132 break;
133 default:
134 /* ignore unknown/unsupported struct */
135 break;
136 }
137 pnext = pnext->pNext;
138 } while (pnext);
139 }
140
141 /* struct VkCommandBufferInheritanceRenderingInfo chain */
142
143 static inline void *
vn_decode_VkCommandBufferInheritanceRenderingInfo_pnext_temp(struct vn_cs_decoder * dec)144 vn_decode_VkCommandBufferInheritanceRenderingInfo_pnext_temp(struct vn_cs_decoder *dec)
145 {
146 /* no known/supported struct */
147 if (vn_decode_simple_pointer(dec))
148 vn_cs_decoder_set_fatal(dec);
149 return NULL;
150 }
151
152 static inline void
vn_decode_VkCommandBufferInheritanceRenderingInfo_self_temp(struct vn_cs_decoder * dec,VkCommandBufferInheritanceRenderingInfo * val)153 vn_decode_VkCommandBufferInheritanceRenderingInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceRenderingInfo *val)
154 {
155 /* skip val->{sType,pNext} */
156 vn_decode_VkFlags(dec, &val->flags);
157 vn_decode_uint32_t(dec, &val->viewMask);
158 vn_decode_uint32_t(dec, &val->colorAttachmentCount);
159 if (vn_peek_array_size(dec)) {
160 const size_t array_size = vn_decode_array_size(dec, val->colorAttachmentCount);
161 val->pColorAttachmentFormats = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pColorAttachmentFormats) * array_size);
162 if (!val->pColorAttachmentFormats) return;
163 vn_decode_VkFormat_array(dec, (VkFormat *)val->pColorAttachmentFormats, array_size);
164 } else {
165 vn_decode_array_size(dec, val->colorAttachmentCount);
166 val->pColorAttachmentFormats = NULL;
167 }
168 vn_decode_VkFormat(dec, &val->depthAttachmentFormat);
169 vn_decode_VkFormat(dec, &val->stencilAttachmentFormat);
170 vn_decode_VkSampleCountFlagBits(dec, &val->rasterizationSamples);
171 }
172
173 static inline void
vn_decode_VkCommandBufferInheritanceRenderingInfo_temp(struct vn_cs_decoder * dec,VkCommandBufferInheritanceRenderingInfo * val)174 vn_decode_VkCommandBufferInheritanceRenderingInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceRenderingInfo *val)
175 {
176 VkStructureType stype;
177 vn_decode_VkStructureType(dec, &stype);
178 if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO)
179 vn_cs_decoder_set_fatal(dec);
180
181 val->sType = stype;
182 val->pNext = vn_decode_VkCommandBufferInheritanceRenderingInfo_pnext_temp(dec);
183 vn_decode_VkCommandBufferInheritanceRenderingInfo_self_temp(dec, val);
184 }
185
186 static inline void
vn_replace_VkCommandBufferInheritanceRenderingInfo_handle_self(VkCommandBufferInheritanceRenderingInfo * val)187 vn_replace_VkCommandBufferInheritanceRenderingInfo_handle_self(VkCommandBufferInheritanceRenderingInfo *val)
188 {
189 /* skip val->sType */
190 /* skip val->pNext */
191 /* skip val->flags */
192 /* skip val->viewMask */
193 /* skip val->colorAttachmentCount */
194 /* skip val->pColorAttachmentFormats */
195 /* skip val->depthAttachmentFormat */
196 /* skip val->stencilAttachmentFormat */
197 /* skip val->rasterizationSamples */
198 }
199
200 static inline void
vn_replace_VkCommandBufferInheritanceRenderingInfo_handle(VkCommandBufferInheritanceRenderingInfo * val)201 vn_replace_VkCommandBufferInheritanceRenderingInfo_handle(VkCommandBufferInheritanceRenderingInfo *val)
202 {
203 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
204
205 do {
206 switch ((int32_t)pnext->sType) {
207 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
208 vn_replace_VkCommandBufferInheritanceRenderingInfo_handle_self((VkCommandBufferInheritanceRenderingInfo *)pnext);
209 break;
210 default:
211 /* ignore unknown/unsupported struct */
212 break;
213 }
214 pnext = pnext->pNext;
215 } while (pnext);
216 }
217
218 /* struct VkCommandBufferInheritanceInfo chain */
219
220 static inline void *
vn_decode_VkCommandBufferInheritanceInfo_pnext_temp(struct vn_cs_decoder * dec)221 vn_decode_VkCommandBufferInheritanceInfo_pnext_temp(struct vn_cs_decoder *dec)
222 {
223 VkBaseOutStructure *pnext;
224 VkStructureType stype;
225
226 if (!vn_decode_simple_pointer(dec))
227 return NULL;
228
229 vn_decode_VkStructureType(dec, &stype);
230 switch ((int32_t)stype) {
231 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
232 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT));
233 if (pnext) {
234 pnext->sType = stype;
235 pnext->pNext = vn_decode_VkCommandBufferInheritanceInfo_pnext_temp(dec);
236 vn_decode_VkCommandBufferInheritanceConditionalRenderingInfoEXT_self_temp(dec, (VkCommandBufferInheritanceConditionalRenderingInfoEXT *)pnext);
237 }
238 break;
239 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
240 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkCommandBufferInheritanceRenderingInfo));
241 if (pnext) {
242 pnext->sType = stype;
243 pnext->pNext = vn_decode_VkCommandBufferInheritanceInfo_pnext_temp(dec);
244 vn_decode_VkCommandBufferInheritanceRenderingInfo_self_temp(dec, (VkCommandBufferInheritanceRenderingInfo *)pnext);
245 }
246 break;
247 default:
248 /* unexpected struct */
249 pnext = NULL;
250 vn_cs_decoder_set_fatal(dec);
251 break;
252 }
253
254 return pnext;
255 }
256
257 static inline void
vn_decode_VkCommandBufferInheritanceInfo_self_temp(struct vn_cs_decoder * dec,VkCommandBufferInheritanceInfo * val)258 vn_decode_VkCommandBufferInheritanceInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val)
259 {
260 /* skip val->{sType,pNext} */
261 vn_decode_VkRenderPass_lookup(dec, &val->renderPass);
262 vn_decode_uint32_t(dec, &val->subpass);
263 vn_decode_VkFramebuffer_lookup(dec, &val->framebuffer);
264 vn_decode_VkBool32(dec, &val->occlusionQueryEnable);
265 vn_decode_VkFlags(dec, &val->queryFlags);
266 vn_decode_VkFlags(dec, &val->pipelineStatistics);
267 }
268
269 static inline void
vn_decode_VkCommandBufferInheritanceInfo_temp(struct vn_cs_decoder * dec,VkCommandBufferInheritanceInfo * val)270 vn_decode_VkCommandBufferInheritanceInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferInheritanceInfo *val)
271 {
272 VkStructureType stype;
273 vn_decode_VkStructureType(dec, &stype);
274 if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO)
275 vn_cs_decoder_set_fatal(dec);
276
277 val->sType = stype;
278 val->pNext = vn_decode_VkCommandBufferInheritanceInfo_pnext_temp(dec);
279 vn_decode_VkCommandBufferInheritanceInfo_self_temp(dec, val);
280 }
281
282 static inline void
vn_replace_VkCommandBufferInheritanceInfo_handle_self(VkCommandBufferInheritanceInfo * val)283 vn_replace_VkCommandBufferInheritanceInfo_handle_self(VkCommandBufferInheritanceInfo *val)
284 {
285 /* skip val->sType */
286 /* skip val->pNext */
287 vn_replace_VkRenderPass_handle(&val->renderPass);
288 /* skip val->subpass */
289 vn_replace_VkFramebuffer_handle(&val->framebuffer);
290 /* skip val->occlusionQueryEnable */
291 /* skip val->queryFlags */
292 /* skip val->pipelineStatistics */
293 }
294
295 static inline void
vn_replace_VkCommandBufferInheritanceInfo_handle(VkCommandBufferInheritanceInfo * val)296 vn_replace_VkCommandBufferInheritanceInfo_handle(VkCommandBufferInheritanceInfo *val)
297 {
298 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
299
300 do {
301 switch ((int32_t)pnext->sType) {
302 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
303 vn_replace_VkCommandBufferInheritanceInfo_handle_self((VkCommandBufferInheritanceInfo *)pnext);
304 break;
305 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
306 vn_replace_VkCommandBufferInheritanceConditionalRenderingInfoEXT_handle_self((VkCommandBufferInheritanceConditionalRenderingInfoEXT *)pnext);
307 break;
308 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
309 vn_replace_VkCommandBufferInheritanceRenderingInfo_handle_self((VkCommandBufferInheritanceRenderingInfo *)pnext);
310 break;
311 default:
312 /* ignore unknown/unsupported struct */
313 break;
314 }
315 pnext = pnext->pNext;
316 } while (pnext);
317 }
318
319 /* struct VkDeviceGroupCommandBufferBeginInfo chain */
320
321 static inline void *
vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext_temp(struct vn_cs_decoder * dec)322 vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext_temp(struct vn_cs_decoder *dec)
323 {
324 /* no known/supported struct */
325 if (vn_decode_simple_pointer(dec))
326 vn_cs_decoder_set_fatal(dec);
327 return NULL;
328 }
329
330 static inline void
vn_decode_VkDeviceGroupCommandBufferBeginInfo_self_temp(struct vn_cs_decoder * dec,VkDeviceGroupCommandBufferBeginInfo * val)331 vn_decode_VkDeviceGroupCommandBufferBeginInfo_self_temp(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val)
332 {
333 /* skip val->{sType,pNext} */
334 vn_decode_uint32_t(dec, &val->deviceMask);
335 }
336
337 static inline void
vn_decode_VkDeviceGroupCommandBufferBeginInfo_temp(struct vn_cs_decoder * dec,VkDeviceGroupCommandBufferBeginInfo * val)338 vn_decode_VkDeviceGroupCommandBufferBeginInfo_temp(struct vn_cs_decoder *dec, VkDeviceGroupCommandBufferBeginInfo *val)
339 {
340 VkStructureType stype;
341 vn_decode_VkStructureType(dec, &stype);
342 if (stype != VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO)
343 vn_cs_decoder_set_fatal(dec);
344
345 val->sType = stype;
346 val->pNext = vn_decode_VkDeviceGroupCommandBufferBeginInfo_pnext_temp(dec);
347 vn_decode_VkDeviceGroupCommandBufferBeginInfo_self_temp(dec, val);
348 }
349
350 static inline void
vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle_self(VkDeviceGroupCommandBufferBeginInfo * val)351 vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle_self(VkDeviceGroupCommandBufferBeginInfo *val)
352 {
353 /* skip val->sType */
354 /* skip val->pNext */
355 /* skip val->deviceMask */
356 }
357
358 static inline void
vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle(VkDeviceGroupCommandBufferBeginInfo * val)359 vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle(VkDeviceGroupCommandBufferBeginInfo *val)
360 {
361 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
362
363 do {
364 switch ((int32_t)pnext->sType) {
365 case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
366 vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle_self((VkDeviceGroupCommandBufferBeginInfo *)pnext);
367 break;
368 default:
369 /* ignore unknown/unsupported struct */
370 break;
371 }
372 pnext = pnext->pNext;
373 } while (pnext);
374 }
375
376 /* struct VkCommandBufferBeginInfo chain */
377
378 static inline void *
vn_decode_VkCommandBufferBeginInfo_pnext_temp(struct vn_cs_decoder * dec)379 vn_decode_VkCommandBufferBeginInfo_pnext_temp(struct vn_cs_decoder *dec)
380 {
381 VkBaseOutStructure *pnext;
382 VkStructureType stype;
383
384 if (!vn_decode_simple_pointer(dec))
385 return NULL;
386
387 vn_decode_VkStructureType(dec, &stype);
388 switch ((int32_t)stype) {
389 case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
390 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDeviceGroupCommandBufferBeginInfo));
391 if (pnext) {
392 pnext->sType = stype;
393 pnext->pNext = vn_decode_VkCommandBufferBeginInfo_pnext_temp(dec);
394 vn_decode_VkDeviceGroupCommandBufferBeginInfo_self_temp(dec, (VkDeviceGroupCommandBufferBeginInfo *)pnext);
395 }
396 break;
397 default:
398 /* unexpected struct */
399 pnext = NULL;
400 vn_cs_decoder_set_fatal(dec);
401 break;
402 }
403
404 return pnext;
405 }
406
407 static inline void
vn_decode_VkCommandBufferBeginInfo_self_temp(struct vn_cs_decoder * dec,VkCommandBufferBeginInfo * val)408 vn_decode_VkCommandBufferBeginInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val)
409 {
410 /* skip val->{sType,pNext} */
411 vn_decode_VkFlags(dec, &val->flags);
412 if (vn_decode_simple_pointer(dec)) {
413 val->pInheritanceInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pInheritanceInfo));
414 if (!val->pInheritanceInfo) return;
415 vn_decode_VkCommandBufferInheritanceInfo_temp(dec, (VkCommandBufferInheritanceInfo *)val->pInheritanceInfo);
416 } else {
417 val->pInheritanceInfo = NULL;
418 }
419 }
420
421 static inline void
vn_decode_VkCommandBufferBeginInfo_temp(struct vn_cs_decoder * dec,VkCommandBufferBeginInfo * val)422 vn_decode_VkCommandBufferBeginInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferBeginInfo *val)
423 {
424 VkStructureType stype;
425 vn_decode_VkStructureType(dec, &stype);
426 if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
427 vn_cs_decoder_set_fatal(dec);
428
429 val->sType = stype;
430 val->pNext = vn_decode_VkCommandBufferBeginInfo_pnext_temp(dec);
431 vn_decode_VkCommandBufferBeginInfo_self_temp(dec, val);
432 }
433
434 static inline void
vn_replace_VkCommandBufferBeginInfo_handle_self(VkCommandBufferBeginInfo * val)435 vn_replace_VkCommandBufferBeginInfo_handle_self(VkCommandBufferBeginInfo *val)
436 {
437 /* skip val->sType */
438 /* skip val->pNext */
439 /* skip val->flags */
440 if (val->pInheritanceInfo)
441 vn_replace_VkCommandBufferInheritanceInfo_handle((VkCommandBufferInheritanceInfo *)val->pInheritanceInfo);
442 }
443
444 static inline void
vn_replace_VkCommandBufferBeginInfo_handle(VkCommandBufferBeginInfo * val)445 vn_replace_VkCommandBufferBeginInfo_handle(VkCommandBufferBeginInfo *val)
446 {
447 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
448
449 do {
450 switch ((int32_t)pnext->sType) {
451 case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
452 vn_replace_VkCommandBufferBeginInfo_handle_self((VkCommandBufferBeginInfo *)pnext);
453 break;
454 case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
455 vn_replace_VkDeviceGroupCommandBufferBeginInfo_handle_self((VkDeviceGroupCommandBufferBeginInfo *)pnext);
456 break;
457 default:
458 /* ignore unknown/unsupported struct */
459 break;
460 }
461 pnext = pnext->pNext;
462 } while (pnext);
463 }
464
465 /* struct VkMultiDrawInfoEXT */
466
467 static inline void
vn_decode_VkMultiDrawInfoEXT_temp(struct vn_cs_decoder * dec,VkMultiDrawInfoEXT * val)468 vn_decode_VkMultiDrawInfoEXT_temp(struct vn_cs_decoder *dec, VkMultiDrawInfoEXT *val)
469 {
470 vn_decode_uint32_t(dec, &val->firstVertex);
471 vn_decode_uint32_t(dec, &val->vertexCount);
472 }
473
474 static inline void
vn_replace_VkMultiDrawInfoEXT_handle(VkMultiDrawInfoEXT * val)475 vn_replace_VkMultiDrawInfoEXT_handle(VkMultiDrawInfoEXT *val)
476 {
477 /* skip val->firstVertex */
478 /* skip val->vertexCount */
479 }
480
481 /* struct VkMultiDrawIndexedInfoEXT */
482
483 static inline void
vn_decode_VkMultiDrawIndexedInfoEXT_temp(struct vn_cs_decoder * dec,VkMultiDrawIndexedInfoEXT * val)484 vn_decode_VkMultiDrawIndexedInfoEXT_temp(struct vn_cs_decoder *dec, VkMultiDrawIndexedInfoEXT *val)
485 {
486 vn_decode_uint32_t(dec, &val->firstIndex);
487 vn_decode_uint32_t(dec, &val->indexCount);
488 vn_decode_int32_t(dec, &val->vertexOffset);
489 }
490
491 static inline void
vn_replace_VkMultiDrawIndexedInfoEXT_handle(VkMultiDrawIndexedInfoEXT * val)492 vn_replace_VkMultiDrawIndexedInfoEXT_handle(VkMultiDrawIndexedInfoEXT *val)
493 {
494 /* skip val->firstIndex */
495 /* skip val->indexCount */
496 /* skip val->vertexOffset */
497 }
498
499 /* struct VkBufferCopy */
500
501 static inline void
vn_decode_VkBufferCopy_temp(struct vn_cs_decoder * dec,VkBufferCopy * val)502 vn_decode_VkBufferCopy_temp(struct vn_cs_decoder *dec, VkBufferCopy *val)
503 {
504 vn_decode_VkDeviceSize(dec, &val->srcOffset);
505 vn_decode_VkDeviceSize(dec, &val->dstOffset);
506 vn_decode_VkDeviceSize(dec, &val->size);
507 }
508
509 static inline void
vn_replace_VkBufferCopy_handle(VkBufferCopy * val)510 vn_replace_VkBufferCopy_handle(VkBufferCopy *val)
511 {
512 /* skip val->srcOffset */
513 /* skip val->dstOffset */
514 /* skip val->size */
515 }
516
517 /* struct VkImageSubresourceLayers */
518
519 static inline void
vn_decode_VkImageSubresourceLayers_temp(struct vn_cs_decoder * dec,VkImageSubresourceLayers * val)520 vn_decode_VkImageSubresourceLayers_temp(struct vn_cs_decoder *dec, VkImageSubresourceLayers *val)
521 {
522 vn_decode_VkFlags(dec, &val->aspectMask);
523 vn_decode_uint32_t(dec, &val->mipLevel);
524 vn_decode_uint32_t(dec, &val->baseArrayLayer);
525 vn_decode_uint32_t(dec, &val->layerCount);
526 }
527
528 static inline void
vn_replace_VkImageSubresourceLayers_handle(VkImageSubresourceLayers * val)529 vn_replace_VkImageSubresourceLayers_handle(VkImageSubresourceLayers *val)
530 {
531 /* skip val->aspectMask */
532 /* skip val->mipLevel */
533 /* skip val->baseArrayLayer */
534 /* skip val->layerCount */
535 }
536
537 /* struct VkImageCopy */
538
539 static inline void
vn_decode_VkImageCopy_temp(struct vn_cs_decoder * dec,VkImageCopy * val)540 vn_decode_VkImageCopy_temp(struct vn_cs_decoder *dec, VkImageCopy *val)
541 {
542 vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource);
543 vn_decode_VkOffset3D_temp(dec, &val->srcOffset);
544 vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource);
545 vn_decode_VkOffset3D_temp(dec, &val->dstOffset);
546 vn_decode_VkExtent3D_temp(dec, &val->extent);
547 }
548
549 static inline void
vn_replace_VkImageCopy_handle(VkImageCopy * val)550 vn_replace_VkImageCopy_handle(VkImageCopy *val)
551 {
552 vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource);
553 vn_replace_VkOffset3D_handle(&val->srcOffset);
554 vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource);
555 vn_replace_VkOffset3D_handle(&val->dstOffset);
556 vn_replace_VkExtent3D_handle(&val->extent);
557 }
558
559 /* struct VkImageBlit */
560
561 static inline void
vn_decode_VkImageBlit_temp(struct vn_cs_decoder * dec,VkImageBlit * val)562 vn_decode_VkImageBlit_temp(struct vn_cs_decoder *dec, VkImageBlit *val)
563 {
564 vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource);
565 {
566 const uint32_t iter_count = vn_decode_array_size(dec, 2);
567 for (uint32_t i = 0; i < iter_count; i++)
568 vn_decode_VkOffset3D_temp(dec, &val->srcOffsets[i]);
569 }
570 vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource);
571 {
572 const uint32_t iter_count = vn_decode_array_size(dec, 2);
573 for (uint32_t i = 0; i < iter_count; i++)
574 vn_decode_VkOffset3D_temp(dec, &val->dstOffsets[i]);
575 }
576 }
577
578 static inline void
vn_replace_VkImageBlit_handle(VkImageBlit * val)579 vn_replace_VkImageBlit_handle(VkImageBlit *val)
580 {
581 vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource);
582 for (uint32_t i = 0; i < 2; i++)
583 vn_replace_VkOffset3D_handle(&val->srcOffsets[i]);
584 vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource);
585 for (uint32_t i = 0; i < 2; i++)
586 vn_replace_VkOffset3D_handle(&val->dstOffsets[i]);
587 }
588
589 /* struct VkBufferImageCopy */
590
591 static inline void
vn_decode_VkBufferImageCopy_temp(struct vn_cs_decoder * dec,VkBufferImageCopy * val)592 vn_decode_VkBufferImageCopy_temp(struct vn_cs_decoder *dec, VkBufferImageCopy *val)
593 {
594 vn_decode_VkDeviceSize(dec, &val->bufferOffset);
595 vn_decode_uint32_t(dec, &val->bufferRowLength);
596 vn_decode_uint32_t(dec, &val->bufferImageHeight);
597 vn_decode_VkImageSubresourceLayers_temp(dec, &val->imageSubresource);
598 vn_decode_VkOffset3D_temp(dec, &val->imageOffset);
599 vn_decode_VkExtent3D_temp(dec, &val->imageExtent);
600 }
601
602 static inline void
vn_replace_VkBufferImageCopy_handle(VkBufferImageCopy * val)603 vn_replace_VkBufferImageCopy_handle(VkBufferImageCopy *val)
604 {
605 /* skip val->bufferOffset */
606 /* skip val->bufferRowLength */
607 /* skip val->bufferImageHeight */
608 vn_replace_VkImageSubresourceLayers_handle(&val->imageSubresource);
609 vn_replace_VkOffset3D_handle(&val->imageOffset);
610 vn_replace_VkExtent3D_handle(&val->imageExtent);
611 }
612
613 /* struct VkClearDepthStencilValue */
614
615 static inline void
vn_decode_VkClearDepthStencilValue_temp(struct vn_cs_decoder * dec,VkClearDepthStencilValue * val)616 vn_decode_VkClearDepthStencilValue_temp(struct vn_cs_decoder *dec, VkClearDepthStencilValue *val)
617 {
618 vn_decode_float(dec, &val->depth);
619 vn_decode_uint32_t(dec, &val->stencil);
620 }
621
622 static inline void
vn_replace_VkClearDepthStencilValue_handle(VkClearDepthStencilValue * val)623 vn_replace_VkClearDepthStencilValue_handle(VkClearDepthStencilValue *val)
624 {
625 /* skip val->depth */
626 /* skip val->stencil */
627 }
628
629 /* union VkClearValue */
630
631 static inline void
vn_decode_VkClearValue_temp(struct vn_cs_decoder * dec,VkClearValue * val)632 vn_decode_VkClearValue_temp(struct vn_cs_decoder *dec, VkClearValue *val)
633 {
634 uint32_t tag;
635 vn_decode_uint32_t(dec, &tag);
636 switch (tag) {
637 case 0:
638 vn_decode_VkClearColorValue_temp(dec, &val->color);
639 break;
640 case 1:
641 vn_decode_VkClearDepthStencilValue_temp(dec, &val->depthStencil);
642 break;
643 default:
644 vn_cs_decoder_set_fatal(dec);
645 break;
646 }
647 }
648
649 /* struct VkClearAttachment */
650
651 static inline void
vn_decode_VkClearAttachment_temp(struct vn_cs_decoder * dec,VkClearAttachment * val)652 vn_decode_VkClearAttachment_temp(struct vn_cs_decoder *dec, VkClearAttachment *val)
653 {
654 vn_decode_VkFlags(dec, &val->aspectMask);
655 vn_decode_uint32_t(dec, &val->colorAttachment);
656 vn_decode_VkClearValue_temp(dec, &val->clearValue);
657 }
658
659 static inline void
vn_replace_VkClearAttachment_handle(VkClearAttachment * val)660 vn_replace_VkClearAttachment_handle(VkClearAttachment *val)
661 {
662 /* skip val->aspectMask */
663 /* skip val->colorAttachment */
664 /* skip val->clearValue */
665 }
666
667 /* struct VkClearRect */
668
669 static inline void
vn_decode_VkClearRect_temp(struct vn_cs_decoder * dec,VkClearRect * val)670 vn_decode_VkClearRect_temp(struct vn_cs_decoder *dec, VkClearRect *val)
671 {
672 vn_decode_VkRect2D_temp(dec, &val->rect);
673 vn_decode_uint32_t(dec, &val->baseArrayLayer);
674 vn_decode_uint32_t(dec, &val->layerCount);
675 }
676
677 static inline void
vn_replace_VkClearRect_handle(VkClearRect * val)678 vn_replace_VkClearRect_handle(VkClearRect *val)
679 {
680 vn_replace_VkRect2D_handle(&val->rect);
681 /* skip val->baseArrayLayer */
682 /* skip val->layerCount */
683 }
684
685 /* struct VkImageResolve */
686
687 static inline void
vn_decode_VkImageResolve_temp(struct vn_cs_decoder * dec,VkImageResolve * val)688 vn_decode_VkImageResolve_temp(struct vn_cs_decoder *dec, VkImageResolve *val)
689 {
690 vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource);
691 vn_decode_VkOffset3D_temp(dec, &val->srcOffset);
692 vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource);
693 vn_decode_VkOffset3D_temp(dec, &val->dstOffset);
694 vn_decode_VkExtent3D_temp(dec, &val->extent);
695 }
696
697 static inline void
vn_replace_VkImageResolve_handle(VkImageResolve * val)698 vn_replace_VkImageResolve_handle(VkImageResolve *val)
699 {
700 vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource);
701 vn_replace_VkOffset3D_handle(&val->srcOffset);
702 vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource);
703 vn_replace_VkOffset3D_handle(&val->dstOffset);
704 vn_replace_VkExtent3D_handle(&val->extent);
705 }
706
707 /* struct VkMemoryBarrier chain */
708
709 static inline void *
vn_decode_VkMemoryBarrier_pnext_temp(struct vn_cs_decoder * dec)710 vn_decode_VkMemoryBarrier_pnext_temp(struct vn_cs_decoder *dec)
711 {
712 /* no known/supported struct */
713 if (vn_decode_simple_pointer(dec))
714 vn_cs_decoder_set_fatal(dec);
715 return NULL;
716 }
717
718 static inline void
vn_decode_VkMemoryBarrier_self_temp(struct vn_cs_decoder * dec,VkMemoryBarrier * val)719 vn_decode_VkMemoryBarrier_self_temp(struct vn_cs_decoder *dec, VkMemoryBarrier *val)
720 {
721 /* skip val->{sType,pNext} */
722 vn_decode_VkFlags(dec, &val->srcAccessMask);
723 vn_decode_VkFlags(dec, &val->dstAccessMask);
724 }
725
726 static inline void
vn_decode_VkMemoryBarrier_temp(struct vn_cs_decoder * dec,VkMemoryBarrier * val)727 vn_decode_VkMemoryBarrier_temp(struct vn_cs_decoder *dec, VkMemoryBarrier *val)
728 {
729 VkStructureType stype;
730 vn_decode_VkStructureType(dec, &stype);
731 if (stype != VK_STRUCTURE_TYPE_MEMORY_BARRIER)
732 vn_cs_decoder_set_fatal(dec);
733
734 val->sType = stype;
735 val->pNext = vn_decode_VkMemoryBarrier_pnext_temp(dec);
736 vn_decode_VkMemoryBarrier_self_temp(dec, val);
737 }
738
739 static inline void
vn_replace_VkMemoryBarrier_handle_self(VkMemoryBarrier * val)740 vn_replace_VkMemoryBarrier_handle_self(VkMemoryBarrier *val)
741 {
742 /* skip val->sType */
743 /* skip val->pNext */
744 /* skip val->srcAccessMask */
745 /* skip val->dstAccessMask */
746 }
747
748 static inline void
vn_replace_VkMemoryBarrier_handle(VkMemoryBarrier * val)749 vn_replace_VkMemoryBarrier_handle(VkMemoryBarrier *val)
750 {
751 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
752
753 do {
754 switch ((int32_t)pnext->sType) {
755 case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
756 vn_replace_VkMemoryBarrier_handle_self((VkMemoryBarrier *)pnext);
757 break;
758 default:
759 /* ignore unknown/unsupported struct */
760 break;
761 }
762 pnext = pnext->pNext;
763 } while (pnext);
764 }
765
766 /* struct VkBufferMemoryBarrier chain */
767
768 static inline void *
vn_decode_VkBufferMemoryBarrier_pnext_temp(struct vn_cs_decoder * dec)769 vn_decode_VkBufferMemoryBarrier_pnext_temp(struct vn_cs_decoder *dec)
770 {
771 /* no known/supported struct */
772 if (vn_decode_simple_pointer(dec))
773 vn_cs_decoder_set_fatal(dec);
774 return NULL;
775 }
776
777 static inline void
vn_decode_VkBufferMemoryBarrier_self_temp(struct vn_cs_decoder * dec,VkBufferMemoryBarrier * val)778 vn_decode_VkBufferMemoryBarrier_self_temp(struct vn_cs_decoder *dec, VkBufferMemoryBarrier *val)
779 {
780 /* skip val->{sType,pNext} */
781 vn_decode_VkFlags(dec, &val->srcAccessMask);
782 vn_decode_VkFlags(dec, &val->dstAccessMask);
783 vn_decode_uint32_t(dec, &val->srcQueueFamilyIndex);
784 vn_decode_uint32_t(dec, &val->dstQueueFamilyIndex);
785 vn_decode_VkBuffer_lookup(dec, &val->buffer);
786 vn_decode_VkDeviceSize(dec, &val->offset);
787 vn_decode_VkDeviceSize(dec, &val->size);
788 }
789
790 static inline void
vn_decode_VkBufferMemoryBarrier_temp(struct vn_cs_decoder * dec,VkBufferMemoryBarrier * val)791 vn_decode_VkBufferMemoryBarrier_temp(struct vn_cs_decoder *dec, VkBufferMemoryBarrier *val)
792 {
793 VkStructureType stype;
794 vn_decode_VkStructureType(dec, &stype);
795 if (stype != VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER)
796 vn_cs_decoder_set_fatal(dec);
797
798 val->sType = stype;
799 val->pNext = vn_decode_VkBufferMemoryBarrier_pnext_temp(dec);
800 vn_decode_VkBufferMemoryBarrier_self_temp(dec, val);
801 }
802
803 static inline void
vn_replace_VkBufferMemoryBarrier_handle_self(VkBufferMemoryBarrier * val)804 vn_replace_VkBufferMemoryBarrier_handle_self(VkBufferMemoryBarrier *val)
805 {
806 /* skip val->sType */
807 /* skip val->pNext */
808 /* skip val->srcAccessMask */
809 /* skip val->dstAccessMask */
810 /* skip val->srcQueueFamilyIndex */
811 /* skip val->dstQueueFamilyIndex */
812 vn_replace_VkBuffer_handle(&val->buffer);
813 /* skip val->offset */
814 /* skip val->size */
815 }
816
817 static inline void
vn_replace_VkBufferMemoryBarrier_handle(VkBufferMemoryBarrier * val)818 vn_replace_VkBufferMemoryBarrier_handle(VkBufferMemoryBarrier *val)
819 {
820 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
821
822 do {
823 switch ((int32_t)pnext->sType) {
824 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
825 vn_replace_VkBufferMemoryBarrier_handle_self((VkBufferMemoryBarrier *)pnext);
826 break;
827 default:
828 /* ignore unknown/unsupported struct */
829 break;
830 }
831 pnext = pnext->pNext;
832 } while (pnext);
833 }
834
835 /* struct VkImageMemoryBarrier chain */
836
837 static inline void *
vn_decode_VkImageMemoryBarrier_pnext_temp(struct vn_cs_decoder * dec)838 vn_decode_VkImageMemoryBarrier_pnext_temp(struct vn_cs_decoder *dec)
839 {
840 /* no known/supported struct */
841 if (vn_decode_simple_pointer(dec))
842 vn_cs_decoder_set_fatal(dec);
843 return NULL;
844 }
845
846 static inline void
vn_decode_VkImageMemoryBarrier_self_temp(struct vn_cs_decoder * dec,VkImageMemoryBarrier * val)847 vn_decode_VkImageMemoryBarrier_self_temp(struct vn_cs_decoder *dec, VkImageMemoryBarrier *val)
848 {
849 /* skip val->{sType,pNext} */
850 vn_decode_VkFlags(dec, &val->srcAccessMask);
851 vn_decode_VkFlags(dec, &val->dstAccessMask);
852 vn_decode_VkImageLayout(dec, &val->oldLayout);
853 vn_decode_VkImageLayout(dec, &val->newLayout);
854 vn_decode_uint32_t(dec, &val->srcQueueFamilyIndex);
855 vn_decode_uint32_t(dec, &val->dstQueueFamilyIndex);
856 vn_decode_VkImage_lookup(dec, &val->image);
857 vn_decode_VkImageSubresourceRange_temp(dec, &val->subresourceRange);
858 }
859
860 static inline void
vn_decode_VkImageMemoryBarrier_temp(struct vn_cs_decoder * dec,VkImageMemoryBarrier * val)861 vn_decode_VkImageMemoryBarrier_temp(struct vn_cs_decoder *dec, VkImageMemoryBarrier *val)
862 {
863 VkStructureType stype;
864 vn_decode_VkStructureType(dec, &stype);
865 if (stype != VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER)
866 vn_cs_decoder_set_fatal(dec);
867
868 val->sType = stype;
869 val->pNext = vn_decode_VkImageMemoryBarrier_pnext_temp(dec);
870 vn_decode_VkImageMemoryBarrier_self_temp(dec, val);
871 }
872
873 static inline void
vn_replace_VkImageMemoryBarrier_handle_self(VkImageMemoryBarrier * val)874 vn_replace_VkImageMemoryBarrier_handle_self(VkImageMemoryBarrier *val)
875 {
876 /* skip val->sType */
877 /* skip val->pNext */
878 /* skip val->srcAccessMask */
879 /* skip val->dstAccessMask */
880 /* skip val->oldLayout */
881 /* skip val->newLayout */
882 /* skip val->srcQueueFamilyIndex */
883 /* skip val->dstQueueFamilyIndex */
884 vn_replace_VkImage_handle(&val->image);
885 vn_replace_VkImageSubresourceRange_handle(&val->subresourceRange);
886 }
887
888 static inline void
vn_replace_VkImageMemoryBarrier_handle(VkImageMemoryBarrier * val)889 vn_replace_VkImageMemoryBarrier_handle(VkImageMemoryBarrier *val)
890 {
891 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
892
893 do {
894 switch ((int32_t)pnext->sType) {
895 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
896 vn_replace_VkImageMemoryBarrier_handle_self((VkImageMemoryBarrier *)pnext);
897 break;
898 default:
899 /* ignore unknown/unsupported struct */
900 break;
901 }
902 pnext = pnext->pNext;
903 } while (pnext);
904 }
905
906 /* struct VkConditionalRenderingBeginInfoEXT chain */
907
908 static inline void *
vn_decode_VkConditionalRenderingBeginInfoEXT_pnext_temp(struct vn_cs_decoder * dec)909 vn_decode_VkConditionalRenderingBeginInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
910 {
911 /* no known/supported struct */
912 if (vn_decode_simple_pointer(dec))
913 vn_cs_decoder_set_fatal(dec);
914 return NULL;
915 }
916
917 static inline void
vn_decode_VkConditionalRenderingBeginInfoEXT_self_temp(struct vn_cs_decoder * dec,VkConditionalRenderingBeginInfoEXT * val)918 vn_decode_VkConditionalRenderingBeginInfoEXT_self_temp(struct vn_cs_decoder *dec, VkConditionalRenderingBeginInfoEXT *val)
919 {
920 /* skip val->{sType,pNext} */
921 vn_decode_VkBuffer_lookup(dec, &val->buffer);
922 vn_decode_VkDeviceSize(dec, &val->offset);
923 vn_decode_VkFlags(dec, &val->flags);
924 }
925
926 static inline void
vn_decode_VkConditionalRenderingBeginInfoEXT_temp(struct vn_cs_decoder * dec,VkConditionalRenderingBeginInfoEXT * val)927 vn_decode_VkConditionalRenderingBeginInfoEXT_temp(struct vn_cs_decoder *dec, VkConditionalRenderingBeginInfoEXT *val)
928 {
929 VkStructureType stype;
930 vn_decode_VkStructureType(dec, &stype);
931 if (stype != VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT)
932 vn_cs_decoder_set_fatal(dec);
933
934 val->sType = stype;
935 val->pNext = vn_decode_VkConditionalRenderingBeginInfoEXT_pnext_temp(dec);
936 vn_decode_VkConditionalRenderingBeginInfoEXT_self_temp(dec, val);
937 }
938
939 static inline void
vn_replace_VkConditionalRenderingBeginInfoEXT_handle_self(VkConditionalRenderingBeginInfoEXT * val)940 vn_replace_VkConditionalRenderingBeginInfoEXT_handle_self(VkConditionalRenderingBeginInfoEXT *val)
941 {
942 /* skip val->sType */
943 /* skip val->pNext */
944 vn_replace_VkBuffer_handle(&val->buffer);
945 /* skip val->offset */
946 /* skip val->flags */
947 }
948
949 static inline void
vn_replace_VkConditionalRenderingBeginInfoEXT_handle(VkConditionalRenderingBeginInfoEXT * val)950 vn_replace_VkConditionalRenderingBeginInfoEXT_handle(VkConditionalRenderingBeginInfoEXT *val)
951 {
952 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
953
954 do {
955 switch ((int32_t)pnext->sType) {
956 case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
957 vn_replace_VkConditionalRenderingBeginInfoEXT_handle_self((VkConditionalRenderingBeginInfoEXT *)pnext);
958 break;
959 default:
960 /* ignore unknown/unsupported struct */
961 break;
962 }
963 pnext = pnext->pNext;
964 } while (pnext);
965 }
966
967 /* struct VkDeviceGroupRenderPassBeginInfo chain */
968
969 static inline void *
vn_decode_VkDeviceGroupRenderPassBeginInfo_pnext_temp(struct vn_cs_decoder * dec)970 vn_decode_VkDeviceGroupRenderPassBeginInfo_pnext_temp(struct vn_cs_decoder *dec)
971 {
972 /* no known/supported struct */
973 if (vn_decode_simple_pointer(dec))
974 vn_cs_decoder_set_fatal(dec);
975 return NULL;
976 }
977
978 static inline void
vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(struct vn_cs_decoder * dec,VkDeviceGroupRenderPassBeginInfo * val)979 vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(struct vn_cs_decoder *dec, VkDeviceGroupRenderPassBeginInfo *val)
980 {
981 /* skip val->{sType,pNext} */
982 vn_decode_uint32_t(dec, &val->deviceMask);
983 vn_decode_uint32_t(dec, &val->deviceRenderAreaCount);
984 if (vn_peek_array_size(dec)) {
985 const uint32_t iter_count = vn_decode_array_size(dec, val->deviceRenderAreaCount);
986 val->pDeviceRenderAreas = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDeviceRenderAreas) * iter_count);
987 if (!val->pDeviceRenderAreas) return;
988 for (uint32_t i = 0; i < iter_count; i++)
989 vn_decode_VkRect2D_temp(dec, &((VkRect2D *)val->pDeviceRenderAreas)[i]);
990 } else {
991 vn_decode_array_size(dec, val->deviceRenderAreaCount);
992 val->pDeviceRenderAreas = NULL;
993 }
994 }
995
996 static inline void
vn_decode_VkDeviceGroupRenderPassBeginInfo_temp(struct vn_cs_decoder * dec,VkDeviceGroupRenderPassBeginInfo * val)997 vn_decode_VkDeviceGroupRenderPassBeginInfo_temp(struct vn_cs_decoder *dec, VkDeviceGroupRenderPassBeginInfo *val)
998 {
999 VkStructureType stype;
1000 vn_decode_VkStructureType(dec, &stype);
1001 if (stype != VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO)
1002 vn_cs_decoder_set_fatal(dec);
1003
1004 val->sType = stype;
1005 val->pNext = vn_decode_VkDeviceGroupRenderPassBeginInfo_pnext_temp(dec);
1006 vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(dec, val);
1007 }
1008
1009 static inline void
vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self(VkDeviceGroupRenderPassBeginInfo * val)1010 vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self(VkDeviceGroupRenderPassBeginInfo *val)
1011 {
1012 /* skip val->sType */
1013 /* skip val->pNext */
1014 /* skip val->deviceMask */
1015 /* skip val->deviceRenderAreaCount */
1016 if (val->pDeviceRenderAreas) {
1017 for (uint32_t i = 0; i < val->deviceRenderAreaCount; i++)
1018 vn_replace_VkRect2D_handle(&((VkRect2D *)val->pDeviceRenderAreas)[i]);
1019 }
1020 }
1021
1022 static inline void
vn_replace_VkDeviceGroupRenderPassBeginInfo_handle(VkDeviceGroupRenderPassBeginInfo * val)1023 vn_replace_VkDeviceGroupRenderPassBeginInfo_handle(VkDeviceGroupRenderPassBeginInfo *val)
1024 {
1025 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1026
1027 do {
1028 switch ((int32_t)pnext->sType) {
1029 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
1030 vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self((VkDeviceGroupRenderPassBeginInfo *)pnext);
1031 break;
1032 default:
1033 /* ignore unknown/unsupported struct */
1034 break;
1035 }
1036 pnext = pnext->pNext;
1037 } while (pnext);
1038 }
1039
1040 /* struct VkRenderPassAttachmentBeginInfo chain */
1041
1042 static inline void *
vn_decode_VkRenderPassAttachmentBeginInfo_pnext_temp(struct vn_cs_decoder * dec)1043 vn_decode_VkRenderPassAttachmentBeginInfo_pnext_temp(struct vn_cs_decoder *dec)
1044 {
1045 /* no known/supported struct */
1046 if (vn_decode_simple_pointer(dec))
1047 vn_cs_decoder_set_fatal(dec);
1048 return NULL;
1049 }
1050
1051 static inline void
vn_decode_VkRenderPassAttachmentBeginInfo_self_temp(struct vn_cs_decoder * dec,VkRenderPassAttachmentBeginInfo * val)1052 vn_decode_VkRenderPassAttachmentBeginInfo_self_temp(struct vn_cs_decoder *dec, VkRenderPassAttachmentBeginInfo *val)
1053 {
1054 /* skip val->{sType,pNext} */
1055 vn_decode_uint32_t(dec, &val->attachmentCount);
1056 if (vn_peek_array_size(dec)) {
1057 const uint32_t iter_count = vn_decode_array_size(dec, val->attachmentCount);
1058 val->pAttachments = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pAttachments) * iter_count);
1059 if (!val->pAttachments) return;
1060 for (uint32_t i = 0; i < iter_count; i++)
1061 vn_decode_VkImageView_lookup(dec, &((VkImageView *)val->pAttachments)[i]);
1062 } else {
1063 vn_decode_array_size(dec, val->attachmentCount);
1064 val->pAttachments = NULL;
1065 }
1066 }
1067
1068 static inline void
vn_decode_VkRenderPassAttachmentBeginInfo_temp(struct vn_cs_decoder * dec,VkRenderPassAttachmentBeginInfo * val)1069 vn_decode_VkRenderPassAttachmentBeginInfo_temp(struct vn_cs_decoder *dec, VkRenderPassAttachmentBeginInfo *val)
1070 {
1071 VkStructureType stype;
1072 vn_decode_VkStructureType(dec, &stype);
1073 if (stype != VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO)
1074 vn_cs_decoder_set_fatal(dec);
1075
1076 val->sType = stype;
1077 val->pNext = vn_decode_VkRenderPassAttachmentBeginInfo_pnext_temp(dec);
1078 vn_decode_VkRenderPassAttachmentBeginInfo_self_temp(dec, val);
1079 }
1080
1081 static inline void
vn_replace_VkRenderPassAttachmentBeginInfo_handle_self(VkRenderPassAttachmentBeginInfo * val)1082 vn_replace_VkRenderPassAttachmentBeginInfo_handle_self(VkRenderPassAttachmentBeginInfo *val)
1083 {
1084 /* skip val->sType */
1085 /* skip val->pNext */
1086 /* skip val->attachmentCount */
1087 if (val->pAttachments) {
1088 for (uint32_t i = 0; i < val->attachmentCount; i++)
1089 vn_replace_VkImageView_handle(&((VkImageView *)val->pAttachments)[i]);
1090 }
1091 }
1092
1093 static inline void
vn_replace_VkRenderPassAttachmentBeginInfo_handle(VkRenderPassAttachmentBeginInfo * val)1094 vn_replace_VkRenderPassAttachmentBeginInfo_handle(VkRenderPassAttachmentBeginInfo *val)
1095 {
1096 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1097
1098 do {
1099 switch ((int32_t)pnext->sType) {
1100 case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
1101 vn_replace_VkRenderPassAttachmentBeginInfo_handle_self((VkRenderPassAttachmentBeginInfo *)pnext);
1102 break;
1103 default:
1104 /* ignore unknown/unsupported struct */
1105 break;
1106 }
1107 pnext = pnext->pNext;
1108 } while (pnext);
1109 }
1110
1111 /* struct VkRenderPassBeginInfo chain */
1112
1113 static inline void *
vn_decode_VkRenderPassBeginInfo_pnext_temp(struct vn_cs_decoder * dec)1114 vn_decode_VkRenderPassBeginInfo_pnext_temp(struct vn_cs_decoder *dec)
1115 {
1116 VkBaseOutStructure *pnext;
1117 VkStructureType stype;
1118
1119 if (!vn_decode_simple_pointer(dec))
1120 return NULL;
1121
1122 vn_decode_VkStructureType(dec, &stype);
1123 switch ((int32_t)stype) {
1124 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
1125 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDeviceGroupRenderPassBeginInfo));
1126 if (pnext) {
1127 pnext->sType = stype;
1128 pnext->pNext = vn_decode_VkRenderPassBeginInfo_pnext_temp(dec);
1129 vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(dec, (VkDeviceGroupRenderPassBeginInfo *)pnext);
1130 }
1131 break;
1132 case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
1133 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkRenderPassAttachmentBeginInfo));
1134 if (pnext) {
1135 pnext->sType = stype;
1136 pnext->pNext = vn_decode_VkRenderPassBeginInfo_pnext_temp(dec);
1137 vn_decode_VkRenderPassAttachmentBeginInfo_self_temp(dec, (VkRenderPassAttachmentBeginInfo *)pnext);
1138 }
1139 break;
1140 default:
1141 /* unexpected struct */
1142 pnext = NULL;
1143 vn_cs_decoder_set_fatal(dec);
1144 break;
1145 }
1146
1147 return pnext;
1148 }
1149
1150 static inline void
vn_decode_VkRenderPassBeginInfo_self_temp(struct vn_cs_decoder * dec,VkRenderPassBeginInfo * val)1151 vn_decode_VkRenderPassBeginInfo_self_temp(struct vn_cs_decoder *dec, VkRenderPassBeginInfo *val)
1152 {
1153 /* skip val->{sType,pNext} */
1154 vn_decode_VkRenderPass_lookup(dec, &val->renderPass);
1155 vn_decode_VkFramebuffer_lookup(dec, &val->framebuffer);
1156 vn_decode_VkRect2D_temp(dec, &val->renderArea);
1157 vn_decode_uint32_t(dec, &val->clearValueCount);
1158 if (vn_peek_array_size(dec)) {
1159 const uint32_t iter_count = vn_decode_array_size(dec, val->clearValueCount);
1160 val->pClearValues = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pClearValues) * iter_count);
1161 if (!val->pClearValues) return;
1162 for (uint32_t i = 0; i < iter_count; i++)
1163 vn_decode_VkClearValue_temp(dec, &((VkClearValue *)val->pClearValues)[i]);
1164 } else {
1165 vn_decode_array_size_unchecked(dec);
1166 val->pClearValues = NULL;
1167 }
1168 }
1169
1170 static inline void
vn_decode_VkRenderPassBeginInfo_temp(struct vn_cs_decoder * dec,VkRenderPassBeginInfo * val)1171 vn_decode_VkRenderPassBeginInfo_temp(struct vn_cs_decoder *dec, VkRenderPassBeginInfo *val)
1172 {
1173 VkStructureType stype;
1174 vn_decode_VkStructureType(dec, &stype);
1175 if (stype != VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO)
1176 vn_cs_decoder_set_fatal(dec);
1177
1178 val->sType = stype;
1179 val->pNext = vn_decode_VkRenderPassBeginInfo_pnext_temp(dec);
1180 vn_decode_VkRenderPassBeginInfo_self_temp(dec, val);
1181 }
1182
1183 static inline void
vn_replace_VkRenderPassBeginInfo_handle_self(VkRenderPassBeginInfo * val)1184 vn_replace_VkRenderPassBeginInfo_handle_self(VkRenderPassBeginInfo *val)
1185 {
1186 /* skip val->sType */
1187 /* skip val->pNext */
1188 vn_replace_VkRenderPass_handle(&val->renderPass);
1189 vn_replace_VkFramebuffer_handle(&val->framebuffer);
1190 vn_replace_VkRect2D_handle(&val->renderArea);
1191 /* skip val->clearValueCount */
1192 /* skip val->pClearValues */
1193 }
1194
1195 static inline void
vn_replace_VkRenderPassBeginInfo_handle(VkRenderPassBeginInfo * val)1196 vn_replace_VkRenderPassBeginInfo_handle(VkRenderPassBeginInfo *val)
1197 {
1198 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1199
1200 do {
1201 switch ((int32_t)pnext->sType) {
1202 case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
1203 vn_replace_VkRenderPassBeginInfo_handle_self((VkRenderPassBeginInfo *)pnext);
1204 break;
1205 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
1206 vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self((VkDeviceGroupRenderPassBeginInfo *)pnext);
1207 break;
1208 case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
1209 vn_replace_VkRenderPassAttachmentBeginInfo_handle_self((VkRenderPassAttachmentBeginInfo *)pnext);
1210 break;
1211 default:
1212 /* ignore unknown/unsupported struct */
1213 break;
1214 }
1215 pnext = pnext->pNext;
1216 } while (pnext);
1217 }
1218
1219 /* struct VkSubpassBeginInfo chain */
1220
1221 static inline void *
vn_decode_VkSubpassBeginInfo_pnext_temp(struct vn_cs_decoder * dec)1222 vn_decode_VkSubpassBeginInfo_pnext_temp(struct vn_cs_decoder *dec)
1223 {
1224 /* no known/supported struct */
1225 if (vn_decode_simple_pointer(dec))
1226 vn_cs_decoder_set_fatal(dec);
1227 return NULL;
1228 }
1229
1230 static inline void
vn_decode_VkSubpassBeginInfo_self_temp(struct vn_cs_decoder * dec,VkSubpassBeginInfo * val)1231 vn_decode_VkSubpassBeginInfo_self_temp(struct vn_cs_decoder *dec, VkSubpassBeginInfo *val)
1232 {
1233 /* skip val->{sType,pNext} */
1234 vn_decode_VkSubpassContents(dec, &val->contents);
1235 }
1236
1237 static inline void
vn_decode_VkSubpassBeginInfo_temp(struct vn_cs_decoder * dec,VkSubpassBeginInfo * val)1238 vn_decode_VkSubpassBeginInfo_temp(struct vn_cs_decoder *dec, VkSubpassBeginInfo *val)
1239 {
1240 VkStructureType stype;
1241 vn_decode_VkStructureType(dec, &stype);
1242 if (stype != VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO)
1243 vn_cs_decoder_set_fatal(dec);
1244
1245 val->sType = stype;
1246 val->pNext = vn_decode_VkSubpassBeginInfo_pnext_temp(dec);
1247 vn_decode_VkSubpassBeginInfo_self_temp(dec, val);
1248 }
1249
1250 static inline void
vn_replace_VkSubpassBeginInfo_handle_self(VkSubpassBeginInfo * val)1251 vn_replace_VkSubpassBeginInfo_handle_self(VkSubpassBeginInfo *val)
1252 {
1253 /* skip val->sType */
1254 /* skip val->pNext */
1255 /* skip val->contents */
1256 }
1257
1258 static inline void
vn_replace_VkSubpassBeginInfo_handle(VkSubpassBeginInfo * val)1259 vn_replace_VkSubpassBeginInfo_handle(VkSubpassBeginInfo *val)
1260 {
1261 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1262
1263 do {
1264 switch ((int32_t)pnext->sType) {
1265 case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
1266 vn_replace_VkSubpassBeginInfo_handle_self((VkSubpassBeginInfo *)pnext);
1267 break;
1268 default:
1269 /* ignore unknown/unsupported struct */
1270 break;
1271 }
1272 pnext = pnext->pNext;
1273 } while (pnext);
1274 }
1275
1276 /* struct VkSubpassEndInfo chain */
1277
1278 static inline void *
vn_decode_VkSubpassEndInfo_pnext_temp(struct vn_cs_decoder * dec)1279 vn_decode_VkSubpassEndInfo_pnext_temp(struct vn_cs_decoder *dec)
1280 {
1281 /* no known/supported struct */
1282 if (vn_decode_simple_pointer(dec))
1283 vn_cs_decoder_set_fatal(dec);
1284 return NULL;
1285 }
1286
1287 static inline void
vn_decode_VkSubpassEndInfo_self_temp(struct vn_cs_decoder * dec,VkSubpassEndInfo * val)1288 vn_decode_VkSubpassEndInfo_self_temp(struct vn_cs_decoder *dec, VkSubpassEndInfo *val)
1289 {
1290 /* skip val->{sType,pNext} */
1291 }
1292
1293 static inline void
vn_decode_VkSubpassEndInfo_temp(struct vn_cs_decoder * dec,VkSubpassEndInfo * val)1294 vn_decode_VkSubpassEndInfo_temp(struct vn_cs_decoder *dec, VkSubpassEndInfo *val)
1295 {
1296 VkStructureType stype;
1297 vn_decode_VkStructureType(dec, &stype);
1298 if (stype != VK_STRUCTURE_TYPE_SUBPASS_END_INFO)
1299 vn_cs_decoder_set_fatal(dec);
1300
1301 val->sType = stype;
1302 val->pNext = vn_decode_VkSubpassEndInfo_pnext_temp(dec);
1303 vn_decode_VkSubpassEndInfo_self_temp(dec, val);
1304 }
1305
1306 static inline void
vn_replace_VkSubpassEndInfo_handle_self(VkSubpassEndInfo * val)1307 vn_replace_VkSubpassEndInfo_handle_self(VkSubpassEndInfo *val)
1308 {
1309 /* skip val->sType */
1310 /* skip val->pNext */
1311 }
1312
1313 static inline void
vn_replace_VkSubpassEndInfo_handle(VkSubpassEndInfo * val)1314 vn_replace_VkSubpassEndInfo_handle(VkSubpassEndInfo *val)
1315 {
1316 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1317
1318 do {
1319 switch ((int32_t)pnext->sType) {
1320 case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
1321 vn_replace_VkSubpassEndInfo_handle_self((VkSubpassEndInfo *)pnext);
1322 break;
1323 default:
1324 /* ignore unknown/unsupported struct */
1325 break;
1326 }
1327 pnext = pnext->pNext;
1328 } while (pnext);
1329 }
1330
1331 /* struct VkBufferCopy2 chain */
1332
1333 static inline void *
vn_decode_VkBufferCopy2_pnext_temp(struct vn_cs_decoder * dec)1334 vn_decode_VkBufferCopy2_pnext_temp(struct vn_cs_decoder *dec)
1335 {
1336 /* no known/supported struct */
1337 if (vn_decode_simple_pointer(dec))
1338 vn_cs_decoder_set_fatal(dec);
1339 return NULL;
1340 }
1341
1342 static inline void
vn_decode_VkBufferCopy2_self_temp(struct vn_cs_decoder * dec,VkBufferCopy2 * val)1343 vn_decode_VkBufferCopy2_self_temp(struct vn_cs_decoder *dec, VkBufferCopy2 *val)
1344 {
1345 /* skip val->{sType,pNext} */
1346 vn_decode_VkDeviceSize(dec, &val->srcOffset);
1347 vn_decode_VkDeviceSize(dec, &val->dstOffset);
1348 vn_decode_VkDeviceSize(dec, &val->size);
1349 }
1350
1351 static inline void
vn_decode_VkBufferCopy2_temp(struct vn_cs_decoder * dec,VkBufferCopy2 * val)1352 vn_decode_VkBufferCopy2_temp(struct vn_cs_decoder *dec, VkBufferCopy2 *val)
1353 {
1354 VkStructureType stype;
1355 vn_decode_VkStructureType(dec, &stype);
1356 if (stype != VK_STRUCTURE_TYPE_BUFFER_COPY_2)
1357 vn_cs_decoder_set_fatal(dec);
1358
1359 val->sType = stype;
1360 val->pNext = vn_decode_VkBufferCopy2_pnext_temp(dec);
1361 vn_decode_VkBufferCopy2_self_temp(dec, val);
1362 }
1363
1364 static inline void
vn_replace_VkBufferCopy2_handle_self(VkBufferCopy2 * val)1365 vn_replace_VkBufferCopy2_handle_self(VkBufferCopy2 *val)
1366 {
1367 /* skip val->sType */
1368 /* skip val->pNext */
1369 /* skip val->srcOffset */
1370 /* skip val->dstOffset */
1371 /* skip val->size */
1372 }
1373
1374 static inline void
vn_replace_VkBufferCopy2_handle(VkBufferCopy2 * val)1375 vn_replace_VkBufferCopy2_handle(VkBufferCopy2 *val)
1376 {
1377 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1378
1379 do {
1380 switch ((int32_t)pnext->sType) {
1381 case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
1382 vn_replace_VkBufferCopy2_handle_self((VkBufferCopy2 *)pnext);
1383 break;
1384 default:
1385 /* ignore unknown/unsupported struct */
1386 break;
1387 }
1388 pnext = pnext->pNext;
1389 } while (pnext);
1390 }
1391
1392 /* struct VkCopyBufferInfo2 chain */
1393
1394 static inline void *
vn_decode_VkCopyBufferInfo2_pnext_temp(struct vn_cs_decoder * dec)1395 vn_decode_VkCopyBufferInfo2_pnext_temp(struct vn_cs_decoder *dec)
1396 {
1397 /* no known/supported struct */
1398 if (vn_decode_simple_pointer(dec))
1399 vn_cs_decoder_set_fatal(dec);
1400 return NULL;
1401 }
1402
1403 static inline void
vn_decode_VkCopyBufferInfo2_self_temp(struct vn_cs_decoder * dec,VkCopyBufferInfo2 * val)1404 vn_decode_VkCopyBufferInfo2_self_temp(struct vn_cs_decoder *dec, VkCopyBufferInfo2 *val)
1405 {
1406 /* skip val->{sType,pNext} */
1407 vn_decode_VkBuffer_lookup(dec, &val->srcBuffer);
1408 vn_decode_VkBuffer_lookup(dec, &val->dstBuffer);
1409 vn_decode_uint32_t(dec, &val->regionCount);
1410 if (vn_peek_array_size(dec)) {
1411 const uint32_t iter_count = vn_decode_array_size(dec, val->regionCount);
1412 val->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRegions) * iter_count);
1413 if (!val->pRegions) return;
1414 for (uint32_t i = 0; i < iter_count; i++)
1415 vn_decode_VkBufferCopy2_temp(dec, &((VkBufferCopy2 *)val->pRegions)[i]);
1416 } else {
1417 vn_decode_array_size(dec, val->regionCount);
1418 val->pRegions = NULL;
1419 }
1420 }
1421
1422 static inline void
vn_decode_VkCopyBufferInfo2_temp(struct vn_cs_decoder * dec,VkCopyBufferInfo2 * val)1423 vn_decode_VkCopyBufferInfo2_temp(struct vn_cs_decoder *dec, VkCopyBufferInfo2 *val)
1424 {
1425 VkStructureType stype;
1426 vn_decode_VkStructureType(dec, &stype);
1427 if (stype != VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2)
1428 vn_cs_decoder_set_fatal(dec);
1429
1430 val->sType = stype;
1431 val->pNext = vn_decode_VkCopyBufferInfo2_pnext_temp(dec);
1432 vn_decode_VkCopyBufferInfo2_self_temp(dec, val);
1433 }
1434
1435 static inline void
vn_replace_VkCopyBufferInfo2_handle_self(VkCopyBufferInfo2 * val)1436 vn_replace_VkCopyBufferInfo2_handle_self(VkCopyBufferInfo2 *val)
1437 {
1438 /* skip val->sType */
1439 /* skip val->pNext */
1440 vn_replace_VkBuffer_handle(&val->srcBuffer);
1441 vn_replace_VkBuffer_handle(&val->dstBuffer);
1442 /* skip val->regionCount */
1443 if (val->pRegions) {
1444 for (uint32_t i = 0; i < val->regionCount; i++)
1445 vn_replace_VkBufferCopy2_handle(&((VkBufferCopy2 *)val->pRegions)[i]);
1446 }
1447 }
1448
1449 static inline void
vn_replace_VkCopyBufferInfo2_handle(VkCopyBufferInfo2 * val)1450 vn_replace_VkCopyBufferInfo2_handle(VkCopyBufferInfo2 *val)
1451 {
1452 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1453
1454 do {
1455 switch ((int32_t)pnext->sType) {
1456 case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
1457 vn_replace_VkCopyBufferInfo2_handle_self((VkCopyBufferInfo2 *)pnext);
1458 break;
1459 default:
1460 /* ignore unknown/unsupported struct */
1461 break;
1462 }
1463 pnext = pnext->pNext;
1464 } while (pnext);
1465 }
1466
1467 /* struct VkImageCopy2 chain */
1468
1469 static inline void *
vn_decode_VkImageCopy2_pnext_temp(struct vn_cs_decoder * dec)1470 vn_decode_VkImageCopy2_pnext_temp(struct vn_cs_decoder *dec)
1471 {
1472 /* no known/supported struct */
1473 if (vn_decode_simple_pointer(dec))
1474 vn_cs_decoder_set_fatal(dec);
1475 return NULL;
1476 }
1477
1478 static inline void
vn_decode_VkImageCopy2_self_temp(struct vn_cs_decoder * dec,VkImageCopy2 * val)1479 vn_decode_VkImageCopy2_self_temp(struct vn_cs_decoder *dec, VkImageCopy2 *val)
1480 {
1481 /* skip val->{sType,pNext} */
1482 vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource);
1483 vn_decode_VkOffset3D_temp(dec, &val->srcOffset);
1484 vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource);
1485 vn_decode_VkOffset3D_temp(dec, &val->dstOffset);
1486 vn_decode_VkExtent3D_temp(dec, &val->extent);
1487 }
1488
1489 static inline void
vn_decode_VkImageCopy2_temp(struct vn_cs_decoder * dec,VkImageCopy2 * val)1490 vn_decode_VkImageCopy2_temp(struct vn_cs_decoder *dec, VkImageCopy2 *val)
1491 {
1492 VkStructureType stype;
1493 vn_decode_VkStructureType(dec, &stype);
1494 if (stype != VK_STRUCTURE_TYPE_IMAGE_COPY_2)
1495 vn_cs_decoder_set_fatal(dec);
1496
1497 val->sType = stype;
1498 val->pNext = vn_decode_VkImageCopy2_pnext_temp(dec);
1499 vn_decode_VkImageCopy2_self_temp(dec, val);
1500 }
1501
1502 static inline void
vn_replace_VkImageCopy2_handle_self(VkImageCopy2 * val)1503 vn_replace_VkImageCopy2_handle_self(VkImageCopy2 *val)
1504 {
1505 /* skip val->sType */
1506 /* skip val->pNext */
1507 vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource);
1508 vn_replace_VkOffset3D_handle(&val->srcOffset);
1509 vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource);
1510 vn_replace_VkOffset3D_handle(&val->dstOffset);
1511 vn_replace_VkExtent3D_handle(&val->extent);
1512 }
1513
1514 static inline void
vn_replace_VkImageCopy2_handle(VkImageCopy2 * val)1515 vn_replace_VkImageCopy2_handle(VkImageCopy2 *val)
1516 {
1517 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1518
1519 do {
1520 switch ((int32_t)pnext->sType) {
1521 case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
1522 vn_replace_VkImageCopy2_handle_self((VkImageCopy2 *)pnext);
1523 break;
1524 default:
1525 /* ignore unknown/unsupported struct */
1526 break;
1527 }
1528 pnext = pnext->pNext;
1529 } while (pnext);
1530 }
1531
1532 /* struct VkCopyImageInfo2 chain */
1533
1534 static inline void *
vn_decode_VkCopyImageInfo2_pnext_temp(struct vn_cs_decoder * dec)1535 vn_decode_VkCopyImageInfo2_pnext_temp(struct vn_cs_decoder *dec)
1536 {
1537 /* no known/supported struct */
1538 if (vn_decode_simple_pointer(dec))
1539 vn_cs_decoder_set_fatal(dec);
1540 return NULL;
1541 }
1542
1543 static inline void
vn_decode_VkCopyImageInfo2_self_temp(struct vn_cs_decoder * dec,VkCopyImageInfo2 * val)1544 vn_decode_VkCopyImageInfo2_self_temp(struct vn_cs_decoder *dec, VkCopyImageInfo2 *val)
1545 {
1546 /* skip val->{sType,pNext} */
1547 vn_decode_VkImage_lookup(dec, &val->srcImage);
1548 vn_decode_VkImageLayout(dec, &val->srcImageLayout);
1549 vn_decode_VkImage_lookup(dec, &val->dstImage);
1550 vn_decode_VkImageLayout(dec, &val->dstImageLayout);
1551 vn_decode_uint32_t(dec, &val->regionCount);
1552 if (vn_peek_array_size(dec)) {
1553 const uint32_t iter_count = vn_decode_array_size(dec, val->regionCount);
1554 val->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRegions) * iter_count);
1555 if (!val->pRegions) return;
1556 for (uint32_t i = 0; i < iter_count; i++)
1557 vn_decode_VkImageCopy2_temp(dec, &((VkImageCopy2 *)val->pRegions)[i]);
1558 } else {
1559 vn_decode_array_size(dec, val->regionCount);
1560 val->pRegions = NULL;
1561 }
1562 }
1563
1564 static inline void
vn_decode_VkCopyImageInfo2_temp(struct vn_cs_decoder * dec,VkCopyImageInfo2 * val)1565 vn_decode_VkCopyImageInfo2_temp(struct vn_cs_decoder *dec, VkCopyImageInfo2 *val)
1566 {
1567 VkStructureType stype;
1568 vn_decode_VkStructureType(dec, &stype);
1569 if (stype != VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2)
1570 vn_cs_decoder_set_fatal(dec);
1571
1572 val->sType = stype;
1573 val->pNext = vn_decode_VkCopyImageInfo2_pnext_temp(dec);
1574 vn_decode_VkCopyImageInfo2_self_temp(dec, val);
1575 }
1576
1577 static inline void
vn_replace_VkCopyImageInfo2_handle_self(VkCopyImageInfo2 * val)1578 vn_replace_VkCopyImageInfo2_handle_self(VkCopyImageInfo2 *val)
1579 {
1580 /* skip val->sType */
1581 /* skip val->pNext */
1582 vn_replace_VkImage_handle(&val->srcImage);
1583 /* skip val->srcImageLayout */
1584 vn_replace_VkImage_handle(&val->dstImage);
1585 /* skip val->dstImageLayout */
1586 /* skip val->regionCount */
1587 if (val->pRegions) {
1588 for (uint32_t i = 0; i < val->regionCount; i++)
1589 vn_replace_VkImageCopy2_handle(&((VkImageCopy2 *)val->pRegions)[i]);
1590 }
1591 }
1592
1593 static inline void
vn_replace_VkCopyImageInfo2_handle(VkCopyImageInfo2 * val)1594 vn_replace_VkCopyImageInfo2_handle(VkCopyImageInfo2 *val)
1595 {
1596 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1597
1598 do {
1599 switch ((int32_t)pnext->sType) {
1600 case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
1601 vn_replace_VkCopyImageInfo2_handle_self((VkCopyImageInfo2 *)pnext);
1602 break;
1603 default:
1604 /* ignore unknown/unsupported struct */
1605 break;
1606 }
1607 pnext = pnext->pNext;
1608 } while (pnext);
1609 }
1610
1611 /* struct VkImageBlit2 chain */
1612
1613 static inline void *
vn_decode_VkImageBlit2_pnext_temp(struct vn_cs_decoder * dec)1614 vn_decode_VkImageBlit2_pnext_temp(struct vn_cs_decoder *dec)
1615 {
1616 /* no known/supported struct */
1617 if (vn_decode_simple_pointer(dec))
1618 vn_cs_decoder_set_fatal(dec);
1619 return NULL;
1620 }
1621
1622 static inline void
vn_decode_VkImageBlit2_self_temp(struct vn_cs_decoder * dec,VkImageBlit2 * val)1623 vn_decode_VkImageBlit2_self_temp(struct vn_cs_decoder *dec, VkImageBlit2 *val)
1624 {
1625 /* skip val->{sType,pNext} */
1626 vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource);
1627 {
1628 const uint32_t iter_count = vn_decode_array_size(dec, 2);
1629 for (uint32_t i = 0; i < iter_count; i++)
1630 vn_decode_VkOffset3D_temp(dec, &val->srcOffsets[i]);
1631 }
1632 vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource);
1633 {
1634 const uint32_t iter_count = vn_decode_array_size(dec, 2);
1635 for (uint32_t i = 0; i < iter_count; i++)
1636 vn_decode_VkOffset3D_temp(dec, &val->dstOffsets[i]);
1637 }
1638 }
1639
1640 static inline void
vn_decode_VkImageBlit2_temp(struct vn_cs_decoder * dec,VkImageBlit2 * val)1641 vn_decode_VkImageBlit2_temp(struct vn_cs_decoder *dec, VkImageBlit2 *val)
1642 {
1643 VkStructureType stype;
1644 vn_decode_VkStructureType(dec, &stype);
1645 if (stype != VK_STRUCTURE_TYPE_IMAGE_BLIT_2)
1646 vn_cs_decoder_set_fatal(dec);
1647
1648 val->sType = stype;
1649 val->pNext = vn_decode_VkImageBlit2_pnext_temp(dec);
1650 vn_decode_VkImageBlit2_self_temp(dec, val);
1651 }
1652
1653 static inline void
vn_replace_VkImageBlit2_handle_self(VkImageBlit2 * val)1654 vn_replace_VkImageBlit2_handle_self(VkImageBlit2 *val)
1655 {
1656 /* skip val->sType */
1657 /* skip val->pNext */
1658 vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource);
1659 for (uint32_t i = 0; i < 2; i++)
1660 vn_replace_VkOffset3D_handle(&val->srcOffsets[i]);
1661 vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource);
1662 for (uint32_t i = 0; i < 2; i++)
1663 vn_replace_VkOffset3D_handle(&val->dstOffsets[i]);
1664 }
1665
1666 static inline void
vn_replace_VkImageBlit2_handle(VkImageBlit2 * val)1667 vn_replace_VkImageBlit2_handle(VkImageBlit2 *val)
1668 {
1669 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1670
1671 do {
1672 switch ((int32_t)pnext->sType) {
1673 case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
1674 vn_replace_VkImageBlit2_handle_self((VkImageBlit2 *)pnext);
1675 break;
1676 default:
1677 /* ignore unknown/unsupported struct */
1678 break;
1679 }
1680 pnext = pnext->pNext;
1681 } while (pnext);
1682 }
1683
1684 /* struct VkBlitImageInfo2 chain */
1685
1686 static inline void *
vn_decode_VkBlitImageInfo2_pnext_temp(struct vn_cs_decoder * dec)1687 vn_decode_VkBlitImageInfo2_pnext_temp(struct vn_cs_decoder *dec)
1688 {
1689 /* no known/supported struct */
1690 if (vn_decode_simple_pointer(dec))
1691 vn_cs_decoder_set_fatal(dec);
1692 return NULL;
1693 }
1694
1695 static inline void
vn_decode_VkBlitImageInfo2_self_temp(struct vn_cs_decoder * dec,VkBlitImageInfo2 * val)1696 vn_decode_VkBlitImageInfo2_self_temp(struct vn_cs_decoder *dec, VkBlitImageInfo2 *val)
1697 {
1698 /* skip val->{sType,pNext} */
1699 vn_decode_VkImage_lookup(dec, &val->srcImage);
1700 vn_decode_VkImageLayout(dec, &val->srcImageLayout);
1701 vn_decode_VkImage_lookup(dec, &val->dstImage);
1702 vn_decode_VkImageLayout(dec, &val->dstImageLayout);
1703 vn_decode_uint32_t(dec, &val->regionCount);
1704 if (vn_peek_array_size(dec)) {
1705 const uint32_t iter_count = vn_decode_array_size(dec, val->regionCount);
1706 val->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRegions) * iter_count);
1707 if (!val->pRegions) return;
1708 for (uint32_t i = 0; i < iter_count; i++)
1709 vn_decode_VkImageBlit2_temp(dec, &((VkImageBlit2 *)val->pRegions)[i]);
1710 } else {
1711 vn_decode_array_size(dec, val->regionCount);
1712 val->pRegions = NULL;
1713 }
1714 vn_decode_VkFilter(dec, &val->filter);
1715 }
1716
1717 static inline void
vn_decode_VkBlitImageInfo2_temp(struct vn_cs_decoder * dec,VkBlitImageInfo2 * val)1718 vn_decode_VkBlitImageInfo2_temp(struct vn_cs_decoder *dec, VkBlitImageInfo2 *val)
1719 {
1720 VkStructureType stype;
1721 vn_decode_VkStructureType(dec, &stype);
1722 if (stype != VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2)
1723 vn_cs_decoder_set_fatal(dec);
1724
1725 val->sType = stype;
1726 val->pNext = vn_decode_VkBlitImageInfo2_pnext_temp(dec);
1727 vn_decode_VkBlitImageInfo2_self_temp(dec, val);
1728 }
1729
1730 static inline void
vn_replace_VkBlitImageInfo2_handle_self(VkBlitImageInfo2 * val)1731 vn_replace_VkBlitImageInfo2_handle_self(VkBlitImageInfo2 *val)
1732 {
1733 /* skip val->sType */
1734 /* skip val->pNext */
1735 vn_replace_VkImage_handle(&val->srcImage);
1736 /* skip val->srcImageLayout */
1737 vn_replace_VkImage_handle(&val->dstImage);
1738 /* skip val->dstImageLayout */
1739 /* skip val->regionCount */
1740 if (val->pRegions) {
1741 for (uint32_t i = 0; i < val->regionCount; i++)
1742 vn_replace_VkImageBlit2_handle(&((VkImageBlit2 *)val->pRegions)[i]);
1743 }
1744 /* skip val->filter */
1745 }
1746
1747 static inline void
vn_replace_VkBlitImageInfo2_handle(VkBlitImageInfo2 * val)1748 vn_replace_VkBlitImageInfo2_handle(VkBlitImageInfo2 *val)
1749 {
1750 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1751
1752 do {
1753 switch ((int32_t)pnext->sType) {
1754 case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
1755 vn_replace_VkBlitImageInfo2_handle_self((VkBlitImageInfo2 *)pnext);
1756 break;
1757 default:
1758 /* ignore unknown/unsupported struct */
1759 break;
1760 }
1761 pnext = pnext->pNext;
1762 } while (pnext);
1763 }
1764
1765 /* struct VkBufferImageCopy2 chain */
1766
1767 static inline void *
vn_decode_VkBufferImageCopy2_pnext_temp(struct vn_cs_decoder * dec)1768 vn_decode_VkBufferImageCopy2_pnext_temp(struct vn_cs_decoder *dec)
1769 {
1770 /* no known/supported struct */
1771 if (vn_decode_simple_pointer(dec))
1772 vn_cs_decoder_set_fatal(dec);
1773 return NULL;
1774 }
1775
1776 static inline void
vn_decode_VkBufferImageCopy2_self_temp(struct vn_cs_decoder * dec,VkBufferImageCopy2 * val)1777 vn_decode_VkBufferImageCopy2_self_temp(struct vn_cs_decoder *dec, VkBufferImageCopy2 *val)
1778 {
1779 /* skip val->{sType,pNext} */
1780 vn_decode_VkDeviceSize(dec, &val->bufferOffset);
1781 vn_decode_uint32_t(dec, &val->bufferRowLength);
1782 vn_decode_uint32_t(dec, &val->bufferImageHeight);
1783 vn_decode_VkImageSubresourceLayers_temp(dec, &val->imageSubresource);
1784 vn_decode_VkOffset3D_temp(dec, &val->imageOffset);
1785 vn_decode_VkExtent3D_temp(dec, &val->imageExtent);
1786 }
1787
1788 static inline void
vn_decode_VkBufferImageCopy2_temp(struct vn_cs_decoder * dec,VkBufferImageCopy2 * val)1789 vn_decode_VkBufferImageCopy2_temp(struct vn_cs_decoder *dec, VkBufferImageCopy2 *val)
1790 {
1791 VkStructureType stype;
1792 vn_decode_VkStructureType(dec, &stype);
1793 if (stype != VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2)
1794 vn_cs_decoder_set_fatal(dec);
1795
1796 val->sType = stype;
1797 val->pNext = vn_decode_VkBufferImageCopy2_pnext_temp(dec);
1798 vn_decode_VkBufferImageCopy2_self_temp(dec, val);
1799 }
1800
1801 static inline void
vn_replace_VkBufferImageCopy2_handle_self(VkBufferImageCopy2 * val)1802 vn_replace_VkBufferImageCopy2_handle_self(VkBufferImageCopy2 *val)
1803 {
1804 /* skip val->sType */
1805 /* skip val->pNext */
1806 /* skip val->bufferOffset */
1807 /* skip val->bufferRowLength */
1808 /* skip val->bufferImageHeight */
1809 vn_replace_VkImageSubresourceLayers_handle(&val->imageSubresource);
1810 vn_replace_VkOffset3D_handle(&val->imageOffset);
1811 vn_replace_VkExtent3D_handle(&val->imageExtent);
1812 }
1813
1814 static inline void
vn_replace_VkBufferImageCopy2_handle(VkBufferImageCopy2 * val)1815 vn_replace_VkBufferImageCopy2_handle(VkBufferImageCopy2 *val)
1816 {
1817 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1818
1819 do {
1820 switch ((int32_t)pnext->sType) {
1821 case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
1822 vn_replace_VkBufferImageCopy2_handle_self((VkBufferImageCopy2 *)pnext);
1823 break;
1824 default:
1825 /* ignore unknown/unsupported struct */
1826 break;
1827 }
1828 pnext = pnext->pNext;
1829 } while (pnext);
1830 }
1831
1832 /* struct VkCopyBufferToImageInfo2 chain */
1833
1834 static inline void *
vn_decode_VkCopyBufferToImageInfo2_pnext_temp(struct vn_cs_decoder * dec)1835 vn_decode_VkCopyBufferToImageInfo2_pnext_temp(struct vn_cs_decoder *dec)
1836 {
1837 /* no known/supported struct */
1838 if (vn_decode_simple_pointer(dec))
1839 vn_cs_decoder_set_fatal(dec);
1840 return NULL;
1841 }
1842
1843 static inline void
vn_decode_VkCopyBufferToImageInfo2_self_temp(struct vn_cs_decoder * dec,VkCopyBufferToImageInfo2 * val)1844 vn_decode_VkCopyBufferToImageInfo2_self_temp(struct vn_cs_decoder *dec, VkCopyBufferToImageInfo2 *val)
1845 {
1846 /* skip val->{sType,pNext} */
1847 vn_decode_VkBuffer_lookup(dec, &val->srcBuffer);
1848 vn_decode_VkImage_lookup(dec, &val->dstImage);
1849 vn_decode_VkImageLayout(dec, &val->dstImageLayout);
1850 vn_decode_uint32_t(dec, &val->regionCount);
1851 if (vn_peek_array_size(dec)) {
1852 const uint32_t iter_count = vn_decode_array_size(dec, val->regionCount);
1853 val->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRegions) * iter_count);
1854 if (!val->pRegions) return;
1855 for (uint32_t i = 0; i < iter_count; i++)
1856 vn_decode_VkBufferImageCopy2_temp(dec, &((VkBufferImageCopy2 *)val->pRegions)[i]);
1857 } else {
1858 vn_decode_array_size(dec, val->regionCount);
1859 val->pRegions = NULL;
1860 }
1861 }
1862
1863 static inline void
vn_decode_VkCopyBufferToImageInfo2_temp(struct vn_cs_decoder * dec,VkCopyBufferToImageInfo2 * val)1864 vn_decode_VkCopyBufferToImageInfo2_temp(struct vn_cs_decoder *dec, VkCopyBufferToImageInfo2 *val)
1865 {
1866 VkStructureType stype;
1867 vn_decode_VkStructureType(dec, &stype);
1868 if (stype != VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2)
1869 vn_cs_decoder_set_fatal(dec);
1870
1871 val->sType = stype;
1872 val->pNext = vn_decode_VkCopyBufferToImageInfo2_pnext_temp(dec);
1873 vn_decode_VkCopyBufferToImageInfo2_self_temp(dec, val);
1874 }
1875
1876 static inline void
vn_replace_VkCopyBufferToImageInfo2_handle_self(VkCopyBufferToImageInfo2 * val)1877 vn_replace_VkCopyBufferToImageInfo2_handle_self(VkCopyBufferToImageInfo2 *val)
1878 {
1879 /* skip val->sType */
1880 /* skip val->pNext */
1881 vn_replace_VkBuffer_handle(&val->srcBuffer);
1882 vn_replace_VkImage_handle(&val->dstImage);
1883 /* skip val->dstImageLayout */
1884 /* skip val->regionCount */
1885 if (val->pRegions) {
1886 for (uint32_t i = 0; i < val->regionCount; i++)
1887 vn_replace_VkBufferImageCopy2_handle(&((VkBufferImageCopy2 *)val->pRegions)[i]);
1888 }
1889 }
1890
1891 static inline void
vn_replace_VkCopyBufferToImageInfo2_handle(VkCopyBufferToImageInfo2 * val)1892 vn_replace_VkCopyBufferToImageInfo2_handle(VkCopyBufferToImageInfo2 *val)
1893 {
1894 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1895
1896 do {
1897 switch ((int32_t)pnext->sType) {
1898 case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
1899 vn_replace_VkCopyBufferToImageInfo2_handle_self((VkCopyBufferToImageInfo2 *)pnext);
1900 break;
1901 default:
1902 /* ignore unknown/unsupported struct */
1903 break;
1904 }
1905 pnext = pnext->pNext;
1906 } while (pnext);
1907 }
1908
1909 /* struct VkCopyImageToBufferInfo2 chain */
1910
1911 static inline void *
vn_decode_VkCopyImageToBufferInfo2_pnext_temp(struct vn_cs_decoder * dec)1912 vn_decode_VkCopyImageToBufferInfo2_pnext_temp(struct vn_cs_decoder *dec)
1913 {
1914 /* no known/supported struct */
1915 if (vn_decode_simple_pointer(dec))
1916 vn_cs_decoder_set_fatal(dec);
1917 return NULL;
1918 }
1919
1920 static inline void
vn_decode_VkCopyImageToBufferInfo2_self_temp(struct vn_cs_decoder * dec,VkCopyImageToBufferInfo2 * val)1921 vn_decode_VkCopyImageToBufferInfo2_self_temp(struct vn_cs_decoder *dec, VkCopyImageToBufferInfo2 *val)
1922 {
1923 /* skip val->{sType,pNext} */
1924 vn_decode_VkImage_lookup(dec, &val->srcImage);
1925 vn_decode_VkImageLayout(dec, &val->srcImageLayout);
1926 vn_decode_VkBuffer_lookup(dec, &val->dstBuffer);
1927 vn_decode_uint32_t(dec, &val->regionCount);
1928 if (vn_peek_array_size(dec)) {
1929 const uint32_t iter_count = vn_decode_array_size(dec, val->regionCount);
1930 val->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRegions) * iter_count);
1931 if (!val->pRegions) return;
1932 for (uint32_t i = 0; i < iter_count; i++)
1933 vn_decode_VkBufferImageCopy2_temp(dec, &((VkBufferImageCopy2 *)val->pRegions)[i]);
1934 } else {
1935 vn_decode_array_size(dec, val->regionCount);
1936 val->pRegions = NULL;
1937 }
1938 }
1939
1940 static inline void
vn_decode_VkCopyImageToBufferInfo2_temp(struct vn_cs_decoder * dec,VkCopyImageToBufferInfo2 * val)1941 vn_decode_VkCopyImageToBufferInfo2_temp(struct vn_cs_decoder *dec, VkCopyImageToBufferInfo2 *val)
1942 {
1943 VkStructureType stype;
1944 vn_decode_VkStructureType(dec, &stype);
1945 if (stype != VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2)
1946 vn_cs_decoder_set_fatal(dec);
1947
1948 val->sType = stype;
1949 val->pNext = vn_decode_VkCopyImageToBufferInfo2_pnext_temp(dec);
1950 vn_decode_VkCopyImageToBufferInfo2_self_temp(dec, val);
1951 }
1952
1953 static inline void
vn_replace_VkCopyImageToBufferInfo2_handle_self(VkCopyImageToBufferInfo2 * val)1954 vn_replace_VkCopyImageToBufferInfo2_handle_self(VkCopyImageToBufferInfo2 *val)
1955 {
1956 /* skip val->sType */
1957 /* skip val->pNext */
1958 vn_replace_VkImage_handle(&val->srcImage);
1959 /* skip val->srcImageLayout */
1960 vn_replace_VkBuffer_handle(&val->dstBuffer);
1961 /* skip val->regionCount */
1962 if (val->pRegions) {
1963 for (uint32_t i = 0; i < val->regionCount; i++)
1964 vn_replace_VkBufferImageCopy2_handle(&((VkBufferImageCopy2 *)val->pRegions)[i]);
1965 }
1966 }
1967
1968 static inline void
vn_replace_VkCopyImageToBufferInfo2_handle(VkCopyImageToBufferInfo2 * val)1969 vn_replace_VkCopyImageToBufferInfo2_handle(VkCopyImageToBufferInfo2 *val)
1970 {
1971 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1972
1973 do {
1974 switch ((int32_t)pnext->sType) {
1975 case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
1976 vn_replace_VkCopyImageToBufferInfo2_handle_self((VkCopyImageToBufferInfo2 *)pnext);
1977 break;
1978 default:
1979 /* ignore unknown/unsupported struct */
1980 break;
1981 }
1982 pnext = pnext->pNext;
1983 } while (pnext);
1984 }
1985
1986 /* struct VkImageResolve2 chain */
1987
1988 static inline void *
vn_decode_VkImageResolve2_pnext_temp(struct vn_cs_decoder * dec)1989 vn_decode_VkImageResolve2_pnext_temp(struct vn_cs_decoder *dec)
1990 {
1991 /* no known/supported struct */
1992 if (vn_decode_simple_pointer(dec))
1993 vn_cs_decoder_set_fatal(dec);
1994 return NULL;
1995 }
1996
1997 static inline void
vn_decode_VkImageResolve2_self_temp(struct vn_cs_decoder * dec,VkImageResolve2 * val)1998 vn_decode_VkImageResolve2_self_temp(struct vn_cs_decoder *dec, VkImageResolve2 *val)
1999 {
2000 /* skip val->{sType,pNext} */
2001 vn_decode_VkImageSubresourceLayers_temp(dec, &val->srcSubresource);
2002 vn_decode_VkOffset3D_temp(dec, &val->srcOffset);
2003 vn_decode_VkImageSubresourceLayers_temp(dec, &val->dstSubresource);
2004 vn_decode_VkOffset3D_temp(dec, &val->dstOffset);
2005 vn_decode_VkExtent3D_temp(dec, &val->extent);
2006 }
2007
2008 static inline void
vn_decode_VkImageResolve2_temp(struct vn_cs_decoder * dec,VkImageResolve2 * val)2009 vn_decode_VkImageResolve2_temp(struct vn_cs_decoder *dec, VkImageResolve2 *val)
2010 {
2011 VkStructureType stype;
2012 vn_decode_VkStructureType(dec, &stype);
2013 if (stype != VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2)
2014 vn_cs_decoder_set_fatal(dec);
2015
2016 val->sType = stype;
2017 val->pNext = vn_decode_VkImageResolve2_pnext_temp(dec);
2018 vn_decode_VkImageResolve2_self_temp(dec, val);
2019 }
2020
2021 static inline void
vn_replace_VkImageResolve2_handle_self(VkImageResolve2 * val)2022 vn_replace_VkImageResolve2_handle_self(VkImageResolve2 *val)
2023 {
2024 /* skip val->sType */
2025 /* skip val->pNext */
2026 vn_replace_VkImageSubresourceLayers_handle(&val->srcSubresource);
2027 vn_replace_VkOffset3D_handle(&val->srcOffset);
2028 vn_replace_VkImageSubresourceLayers_handle(&val->dstSubresource);
2029 vn_replace_VkOffset3D_handle(&val->dstOffset);
2030 vn_replace_VkExtent3D_handle(&val->extent);
2031 }
2032
2033 static inline void
vn_replace_VkImageResolve2_handle(VkImageResolve2 * val)2034 vn_replace_VkImageResolve2_handle(VkImageResolve2 *val)
2035 {
2036 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2037
2038 do {
2039 switch ((int32_t)pnext->sType) {
2040 case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
2041 vn_replace_VkImageResolve2_handle_self((VkImageResolve2 *)pnext);
2042 break;
2043 default:
2044 /* ignore unknown/unsupported struct */
2045 break;
2046 }
2047 pnext = pnext->pNext;
2048 } while (pnext);
2049 }
2050
2051 /* struct VkResolveImageInfo2 chain */
2052
2053 static inline void *
vn_decode_VkResolveImageInfo2_pnext_temp(struct vn_cs_decoder * dec)2054 vn_decode_VkResolveImageInfo2_pnext_temp(struct vn_cs_decoder *dec)
2055 {
2056 /* no known/supported struct */
2057 if (vn_decode_simple_pointer(dec))
2058 vn_cs_decoder_set_fatal(dec);
2059 return NULL;
2060 }
2061
2062 static inline void
vn_decode_VkResolveImageInfo2_self_temp(struct vn_cs_decoder * dec,VkResolveImageInfo2 * val)2063 vn_decode_VkResolveImageInfo2_self_temp(struct vn_cs_decoder *dec, VkResolveImageInfo2 *val)
2064 {
2065 /* skip val->{sType,pNext} */
2066 vn_decode_VkImage_lookup(dec, &val->srcImage);
2067 vn_decode_VkImageLayout(dec, &val->srcImageLayout);
2068 vn_decode_VkImage_lookup(dec, &val->dstImage);
2069 vn_decode_VkImageLayout(dec, &val->dstImageLayout);
2070 vn_decode_uint32_t(dec, &val->regionCount);
2071 if (vn_peek_array_size(dec)) {
2072 const uint32_t iter_count = vn_decode_array_size(dec, val->regionCount);
2073 val->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRegions) * iter_count);
2074 if (!val->pRegions) return;
2075 for (uint32_t i = 0; i < iter_count; i++)
2076 vn_decode_VkImageResolve2_temp(dec, &((VkImageResolve2 *)val->pRegions)[i]);
2077 } else {
2078 vn_decode_array_size(dec, val->regionCount);
2079 val->pRegions = NULL;
2080 }
2081 }
2082
2083 static inline void
vn_decode_VkResolveImageInfo2_temp(struct vn_cs_decoder * dec,VkResolveImageInfo2 * val)2084 vn_decode_VkResolveImageInfo2_temp(struct vn_cs_decoder *dec, VkResolveImageInfo2 *val)
2085 {
2086 VkStructureType stype;
2087 vn_decode_VkStructureType(dec, &stype);
2088 if (stype != VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2)
2089 vn_cs_decoder_set_fatal(dec);
2090
2091 val->sType = stype;
2092 val->pNext = vn_decode_VkResolveImageInfo2_pnext_temp(dec);
2093 vn_decode_VkResolveImageInfo2_self_temp(dec, val);
2094 }
2095
2096 static inline void
vn_replace_VkResolveImageInfo2_handle_self(VkResolveImageInfo2 * val)2097 vn_replace_VkResolveImageInfo2_handle_self(VkResolveImageInfo2 *val)
2098 {
2099 /* skip val->sType */
2100 /* skip val->pNext */
2101 vn_replace_VkImage_handle(&val->srcImage);
2102 /* skip val->srcImageLayout */
2103 vn_replace_VkImage_handle(&val->dstImage);
2104 /* skip val->dstImageLayout */
2105 /* skip val->regionCount */
2106 if (val->pRegions) {
2107 for (uint32_t i = 0; i < val->regionCount; i++)
2108 vn_replace_VkImageResolve2_handle(&((VkImageResolve2 *)val->pRegions)[i]);
2109 }
2110 }
2111
2112 static inline void
vn_replace_VkResolveImageInfo2_handle(VkResolveImageInfo2 * val)2113 vn_replace_VkResolveImageInfo2_handle(VkResolveImageInfo2 *val)
2114 {
2115 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2116
2117 do {
2118 switch ((int32_t)pnext->sType) {
2119 case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
2120 vn_replace_VkResolveImageInfo2_handle_self((VkResolveImageInfo2 *)pnext);
2121 break;
2122 default:
2123 /* ignore unknown/unsupported struct */
2124 break;
2125 }
2126 pnext = pnext->pNext;
2127 } while (pnext);
2128 }
2129
2130 /* struct VkBufferMemoryBarrier2 chain */
2131
2132 static inline void *
vn_decode_VkBufferMemoryBarrier2_pnext_temp(struct vn_cs_decoder * dec)2133 vn_decode_VkBufferMemoryBarrier2_pnext_temp(struct vn_cs_decoder *dec)
2134 {
2135 /* no known/supported struct */
2136 if (vn_decode_simple_pointer(dec))
2137 vn_cs_decoder_set_fatal(dec);
2138 return NULL;
2139 }
2140
2141 static inline void
vn_decode_VkBufferMemoryBarrier2_self_temp(struct vn_cs_decoder * dec,VkBufferMemoryBarrier2 * val)2142 vn_decode_VkBufferMemoryBarrier2_self_temp(struct vn_cs_decoder *dec, VkBufferMemoryBarrier2 *val)
2143 {
2144 /* skip val->{sType,pNext} */
2145 vn_decode_VkFlags64(dec, &val->srcStageMask);
2146 vn_decode_VkFlags64(dec, &val->srcAccessMask);
2147 vn_decode_VkFlags64(dec, &val->dstStageMask);
2148 vn_decode_VkFlags64(dec, &val->dstAccessMask);
2149 vn_decode_uint32_t(dec, &val->srcQueueFamilyIndex);
2150 vn_decode_uint32_t(dec, &val->dstQueueFamilyIndex);
2151 vn_decode_VkBuffer_lookup(dec, &val->buffer);
2152 vn_decode_VkDeviceSize(dec, &val->offset);
2153 vn_decode_VkDeviceSize(dec, &val->size);
2154 }
2155
2156 static inline void
vn_decode_VkBufferMemoryBarrier2_temp(struct vn_cs_decoder * dec,VkBufferMemoryBarrier2 * val)2157 vn_decode_VkBufferMemoryBarrier2_temp(struct vn_cs_decoder *dec, VkBufferMemoryBarrier2 *val)
2158 {
2159 VkStructureType stype;
2160 vn_decode_VkStructureType(dec, &stype);
2161 if (stype != VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2)
2162 vn_cs_decoder_set_fatal(dec);
2163
2164 val->sType = stype;
2165 val->pNext = vn_decode_VkBufferMemoryBarrier2_pnext_temp(dec);
2166 vn_decode_VkBufferMemoryBarrier2_self_temp(dec, val);
2167 }
2168
2169 static inline void
vn_replace_VkBufferMemoryBarrier2_handle_self(VkBufferMemoryBarrier2 * val)2170 vn_replace_VkBufferMemoryBarrier2_handle_self(VkBufferMemoryBarrier2 *val)
2171 {
2172 /* skip val->sType */
2173 /* skip val->pNext */
2174 /* skip val->srcStageMask */
2175 /* skip val->srcAccessMask */
2176 /* skip val->dstStageMask */
2177 /* skip val->dstAccessMask */
2178 /* skip val->srcQueueFamilyIndex */
2179 /* skip val->dstQueueFamilyIndex */
2180 vn_replace_VkBuffer_handle(&val->buffer);
2181 /* skip val->offset */
2182 /* skip val->size */
2183 }
2184
2185 static inline void
vn_replace_VkBufferMemoryBarrier2_handle(VkBufferMemoryBarrier2 * val)2186 vn_replace_VkBufferMemoryBarrier2_handle(VkBufferMemoryBarrier2 *val)
2187 {
2188 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2189
2190 do {
2191 switch ((int32_t)pnext->sType) {
2192 case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
2193 vn_replace_VkBufferMemoryBarrier2_handle_self((VkBufferMemoryBarrier2 *)pnext);
2194 break;
2195 default:
2196 /* ignore unknown/unsupported struct */
2197 break;
2198 }
2199 pnext = pnext->pNext;
2200 } while (pnext);
2201 }
2202
2203 /* struct VkImageMemoryBarrier2 chain */
2204
2205 static inline void *
vn_decode_VkImageMemoryBarrier2_pnext_temp(struct vn_cs_decoder * dec)2206 vn_decode_VkImageMemoryBarrier2_pnext_temp(struct vn_cs_decoder *dec)
2207 {
2208 /* no known/supported struct */
2209 if (vn_decode_simple_pointer(dec))
2210 vn_cs_decoder_set_fatal(dec);
2211 return NULL;
2212 }
2213
2214 static inline void
vn_decode_VkImageMemoryBarrier2_self_temp(struct vn_cs_decoder * dec,VkImageMemoryBarrier2 * val)2215 vn_decode_VkImageMemoryBarrier2_self_temp(struct vn_cs_decoder *dec, VkImageMemoryBarrier2 *val)
2216 {
2217 /* skip val->{sType,pNext} */
2218 vn_decode_VkFlags64(dec, &val->srcStageMask);
2219 vn_decode_VkFlags64(dec, &val->srcAccessMask);
2220 vn_decode_VkFlags64(dec, &val->dstStageMask);
2221 vn_decode_VkFlags64(dec, &val->dstAccessMask);
2222 vn_decode_VkImageLayout(dec, &val->oldLayout);
2223 vn_decode_VkImageLayout(dec, &val->newLayout);
2224 vn_decode_uint32_t(dec, &val->srcQueueFamilyIndex);
2225 vn_decode_uint32_t(dec, &val->dstQueueFamilyIndex);
2226 vn_decode_VkImage_lookup(dec, &val->image);
2227 vn_decode_VkImageSubresourceRange_temp(dec, &val->subresourceRange);
2228 }
2229
2230 static inline void
vn_decode_VkImageMemoryBarrier2_temp(struct vn_cs_decoder * dec,VkImageMemoryBarrier2 * val)2231 vn_decode_VkImageMemoryBarrier2_temp(struct vn_cs_decoder *dec, VkImageMemoryBarrier2 *val)
2232 {
2233 VkStructureType stype;
2234 vn_decode_VkStructureType(dec, &stype);
2235 if (stype != VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2)
2236 vn_cs_decoder_set_fatal(dec);
2237
2238 val->sType = stype;
2239 val->pNext = vn_decode_VkImageMemoryBarrier2_pnext_temp(dec);
2240 vn_decode_VkImageMemoryBarrier2_self_temp(dec, val);
2241 }
2242
2243 static inline void
vn_replace_VkImageMemoryBarrier2_handle_self(VkImageMemoryBarrier2 * val)2244 vn_replace_VkImageMemoryBarrier2_handle_self(VkImageMemoryBarrier2 *val)
2245 {
2246 /* skip val->sType */
2247 /* skip val->pNext */
2248 /* skip val->srcStageMask */
2249 /* skip val->srcAccessMask */
2250 /* skip val->dstStageMask */
2251 /* skip val->dstAccessMask */
2252 /* skip val->oldLayout */
2253 /* skip val->newLayout */
2254 /* skip val->srcQueueFamilyIndex */
2255 /* skip val->dstQueueFamilyIndex */
2256 vn_replace_VkImage_handle(&val->image);
2257 vn_replace_VkImageSubresourceRange_handle(&val->subresourceRange);
2258 }
2259
2260 static inline void
vn_replace_VkImageMemoryBarrier2_handle(VkImageMemoryBarrier2 * val)2261 vn_replace_VkImageMemoryBarrier2_handle(VkImageMemoryBarrier2 *val)
2262 {
2263 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2264
2265 do {
2266 switch ((int32_t)pnext->sType) {
2267 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
2268 vn_replace_VkImageMemoryBarrier2_handle_self((VkImageMemoryBarrier2 *)pnext);
2269 break;
2270 default:
2271 /* ignore unknown/unsupported struct */
2272 break;
2273 }
2274 pnext = pnext->pNext;
2275 } while (pnext);
2276 }
2277
2278 /* struct VkDependencyInfo chain */
2279
2280 static inline void *
vn_decode_VkDependencyInfo_pnext_temp(struct vn_cs_decoder * dec)2281 vn_decode_VkDependencyInfo_pnext_temp(struct vn_cs_decoder *dec)
2282 {
2283 /* no known/supported struct */
2284 if (vn_decode_simple_pointer(dec))
2285 vn_cs_decoder_set_fatal(dec);
2286 return NULL;
2287 }
2288
2289 static inline void
vn_decode_VkDependencyInfo_self_temp(struct vn_cs_decoder * dec,VkDependencyInfo * val)2290 vn_decode_VkDependencyInfo_self_temp(struct vn_cs_decoder *dec, VkDependencyInfo *val)
2291 {
2292 /* skip val->{sType,pNext} */
2293 vn_decode_VkFlags(dec, &val->dependencyFlags);
2294 vn_decode_uint32_t(dec, &val->memoryBarrierCount);
2295 if (vn_peek_array_size(dec)) {
2296 const uint32_t iter_count = vn_decode_array_size(dec, val->memoryBarrierCount);
2297 val->pMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pMemoryBarriers) * iter_count);
2298 if (!val->pMemoryBarriers) return;
2299 for (uint32_t i = 0; i < iter_count; i++)
2300 vn_decode_VkMemoryBarrier2_temp(dec, &((VkMemoryBarrier2 *)val->pMemoryBarriers)[i]);
2301 } else {
2302 vn_decode_array_size(dec, val->memoryBarrierCount);
2303 val->pMemoryBarriers = NULL;
2304 }
2305 vn_decode_uint32_t(dec, &val->bufferMemoryBarrierCount);
2306 if (vn_peek_array_size(dec)) {
2307 const uint32_t iter_count = vn_decode_array_size(dec, val->bufferMemoryBarrierCount);
2308 val->pBufferMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pBufferMemoryBarriers) * iter_count);
2309 if (!val->pBufferMemoryBarriers) return;
2310 for (uint32_t i = 0; i < iter_count; i++)
2311 vn_decode_VkBufferMemoryBarrier2_temp(dec, &((VkBufferMemoryBarrier2 *)val->pBufferMemoryBarriers)[i]);
2312 } else {
2313 vn_decode_array_size(dec, val->bufferMemoryBarrierCount);
2314 val->pBufferMemoryBarriers = NULL;
2315 }
2316 vn_decode_uint32_t(dec, &val->imageMemoryBarrierCount);
2317 if (vn_peek_array_size(dec)) {
2318 const uint32_t iter_count = vn_decode_array_size(dec, val->imageMemoryBarrierCount);
2319 val->pImageMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pImageMemoryBarriers) * iter_count);
2320 if (!val->pImageMemoryBarriers) return;
2321 for (uint32_t i = 0; i < iter_count; i++)
2322 vn_decode_VkImageMemoryBarrier2_temp(dec, &((VkImageMemoryBarrier2 *)val->pImageMemoryBarriers)[i]);
2323 } else {
2324 vn_decode_array_size(dec, val->imageMemoryBarrierCount);
2325 val->pImageMemoryBarriers = NULL;
2326 }
2327 }
2328
2329 static inline void
vn_decode_VkDependencyInfo_temp(struct vn_cs_decoder * dec,VkDependencyInfo * val)2330 vn_decode_VkDependencyInfo_temp(struct vn_cs_decoder *dec, VkDependencyInfo *val)
2331 {
2332 VkStructureType stype;
2333 vn_decode_VkStructureType(dec, &stype);
2334 if (stype != VK_STRUCTURE_TYPE_DEPENDENCY_INFO)
2335 vn_cs_decoder_set_fatal(dec);
2336
2337 val->sType = stype;
2338 val->pNext = vn_decode_VkDependencyInfo_pnext_temp(dec);
2339 vn_decode_VkDependencyInfo_self_temp(dec, val);
2340 }
2341
2342 static inline void
vn_replace_VkDependencyInfo_handle_self(VkDependencyInfo * val)2343 vn_replace_VkDependencyInfo_handle_self(VkDependencyInfo *val)
2344 {
2345 /* skip val->sType */
2346 /* skip val->pNext */
2347 /* skip val->dependencyFlags */
2348 /* skip val->memoryBarrierCount */
2349 if (val->pMemoryBarriers) {
2350 for (uint32_t i = 0; i < val->memoryBarrierCount; i++)
2351 vn_replace_VkMemoryBarrier2_handle(&((VkMemoryBarrier2 *)val->pMemoryBarriers)[i]);
2352 }
2353 /* skip val->bufferMemoryBarrierCount */
2354 if (val->pBufferMemoryBarriers) {
2355 for (uint32_t i = 0; i < val->bufferMemoryBarrierCount; i++)
2356 vn_replace_VkBufferMemoryBarrier2_handle(&((VkBufferMemoryBarrier2 *)val->pBufferMemoryBarriers)[i]);
2357 }
2358 /* skip val->imageMemoryBarrierCount */
2359 if (val->pImageMemoryBarriers) {
2360 for (uint32_t i = 0; i < val->imageMemoryBarrierCount; i++)
2361 vn_replace_VkImageMemoryBarrier2_handle(&((VkImageMemoryBarrier2 *)val->pImageMemoryBarriers)[i]);
2362 }
2363 }
2364
2365 static inline void
vn_replace_VkDependencyInfo_handle(VkDependencyInfo * val)2366 vn_replace_VkDependencyInfo_handle(VkDependencyInfo *val)
2367 {
2368 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2369
2370 do {
2371 switch ((int32_t)pnext->sType) {
2372 case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
2373 vn_replace_VkDependencyInfo_handle_self((VkDependencyInfo *)pnext);
2374 break;
2375 default:
2376 /* ignore unknown/unsupported struct */
2377 break;
2378 }
2379 pnext = pnext->pNext;
2380 } while (pnext);
2381 }
2382
2383 /* struct VkRenderingAttachmentInfo chain */
2384
2385 static inline void *
vn_decode_VkRenderingAttachmentInfo_pnext_temp(struct vn_cs_decoder * dec)2386 vn_decode_VkRenderingAttachmentInfo_pnext_temp(struct vn_cs_decoder *dec)
2387 {
2388 /* no known/supported struct */
2389 if (vn_decode_simple_pointer(dec))
2390 vn_cs_decoder_set_fatal(dec);
2391 return NULL;
2392 }
2393
2394 static inline void
vn_decode_VkRenderingAttachmentInfo_self_temp(struct vn_cs_decoder * dec,VkRenderingAttachmentInfo * val)2395 vn_decode_VkRenderingAttachmentInfo_self_temp(struct vn_cs_decoder *dec, VkRenderingAttachmentInfo *val)
2396 {
2397 /* skip val->{sType,pNext} */
2398 vn_decode_VkImageView_lookup(dec, &val->imageView);
2399 vn_decode_VkImageLayout(dec, &val->imageLayout);
2400 vn_decode_VkResolveModeFlagBits(dec, &val->resolveMode);
2401 vn_decode_VkImageView_lookup(dec, &val->resolveImageView);
2402 vn_decode_VkImageLayout(dec, &val->resolveImageLayout);
2403 vn_decode_VkAttachmentLoadOp(dec, &val->loadOp);
2404 vn_decode_VkAttachmentStoreOp(dec, &val->storeOp);
2405 vn_decode_VkClearValue_temp(dec, &val->clearValue);
2406 }
2407
2408 static inline void
vn_decode_VkRenderingAttachmentInfo_temp(struct vn_cs_decoder * dec,VkRenderingAttachmentInfo * val)2409 vn_decode_VkRenderingAttachmentInfo_temp(struct vn_cs_decoder *dec, VkRenderingAttachmentInfo *val)
2410 {
2411 VkStructureType stype;
2412 vn_decode_VkStructureType(dec, &stype);
2413 if (stype != VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO)
2414 vn_cs_decoder_set_fatal(dec);
2415
2416 val->sType = stype;
2417 val->pNext = vn_decode_VkRenderingAttachmentInfo_pnext_temp(dec);
2418 vn_decode_VkRenderingAttachmentInfo_self_temp(dec, val);
2419 }
2420
2421 static inline void
vn_replace_VkRenderingAttachmentInfo_handle_self(VkRenderingAttachmentInfo * val)2422 vn_replace_VkRenderingAttachmentInfo_handle_self(VkRenderingAttachmentInfo *val)
2423 {
2424 /* skip val->sType */
2425 /* skip val->pNext */
2426 vn_replace_VkImageView_handle(&val->imageView);
2427 /* skip val->imageLayout */
2428 /* skip val->resolveMode */
2429 vn_replace_VkImageView_handle(&val->resolveImageView);
2430 /* skip val->resolveImageLayout */
2431 /* skip val->loadOp */
2432 /* skip val->storeOp */
2433 /* skip val->clearValue */
2434 }
2435
2436 static inline void
vn_replace_VkRenderingAttachmentInfo_handle(VkRenderingAttachmentInfo * val)2437 vn_replace_VkRenderingAttachmentInfo_handle(VkRenderingAttachmentInfo *val)
2438 {
2439 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2440
2441 do {
2442 switch ((int32_t)pnext->sType) {
2443 case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
2444 vn_replace_VkRenderingAttachmentInfo_handle_self((VkRenderingAttachmentInfo *)pnext);
2445 break;
2446 default:
2447 /* ignore unknown/unsupported struct */
2448 break;
2449 }
2450 pnext = pnext->pNext;
2451 } while (pnext);
2452 }
2453
2454 /* struct VkRenderingInfo chain */
2455
2456 static inline void *
vn_decode_VkRenderingInfo_pnext_temp(struct vn_cs_decoder * dec)2457 vn_decode_VkRenderingInfo_pnext_temp(struct vn_cs_decoder *dec)
2458 {
2459 VkBaseOutStructure *pnext;
2460 VkStructureType stype;
2461
2462 if (!vn_decode_simple_pointer(dec))
2463 return NULL;
2464
2465 vn_decode_VkStructureType(dec, &stype);
2466 switch ((int32_t)stype) {
2467 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
2468 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDeviceGroupRenderPassBeginInfo));
2469 if (pnext) {
2470 pnext->sType = stype;
2471 pnext->pNext = vn_decode_VkRenderingInfo_pnext_temp(dec);
2472 vn_decode_VkDeviceGroupRenderPassBeginInfo_self_temp(dec, (VkDeviceGroupRenderPassBeginInfo *)pnext);
2473 }
2474 break;
2475 default:
2476 /* unexpected struct */
2477 pnext = NULL;
2478 vn_cs_decoder_set_fatal(dec);
2479 break;
2480 }
2481
2482 return pnext;
2483 }
2484
2485 static inline void
vn_decode_VkRenderingInfo_self_temp(struct vn_cs_decoder * dec,VkRenderingInfo * val)2486 vn_decode_VkRenderingInfo_self_temp(struct vn_cs_decoder *dec, VkRenderingInfo *val)
2487 {
2488 /* skip val->{sType,pNext} */
2489 vn_decode_VkFlags(dec, &val->flags);
2490 vn_decode_VkRect2D_temp(dec, &val->renderArea);
2491 vn_decode_uint32_t(dec, &val->layerCount);
2492 vn_decode_uint32_t(dec, &val->viewMask);
2493 vn_decode_uint32_t(dec, &val->colorAttachmentCount);
2494 if (vn_peek_array_size(dec)) {
2495 const uint32_t iter_count = vn_decode_array_size(dec, val->colorAttachmentCount);
2496 val->pColorAttachments = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pColorAttachments) * iter_count);
2497 if (!val->pColorAttachments) return;
2498 for (uint32_t i = 0; i < iter_count; i++)
2499 vn_decode_VkRenderingAttachmentInfo_temp(dec, &((VkRenderingAttachmentInfo *)val->pColorAttachments)[i]);
2500 } else {
2501 vn_decode_array_size(dec, val->colorAttachmentCount);
2502 val->pColorAttachments = NULL;
2503 }
2504 if (vn_decode_simple_pointer(dec)) {
2505 val->pDepthAttachment = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDepthAttachment));
2506 if (!val->pDepthAttachment) return;
2507 vn_decode_VkRenderingAttachmentInfo_temp(dec, (VkRenderingAttachmentInfo *)val->pDepthAttachment);
2508 } else {
2509 val->pDepthAttachment = NULL;
2510 }
2511 if (vn_decode_simple_pointer(dec)) {
2512 val->pStencilAttachment = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pStencilAttachment));
2513 if (!val->pStencilAttachment) return;
2514 vn_decode_VkRenderingAttachmentInfo_temp(dec, (VkRenderingAttachmentInfo *)val->pStencilAttachment);
2515 } else {
2516 val->pStencilAttachment = NULL;
2517 }
2518 }
2519
2520 static inline void
vn_decode_VkRenderingInfo_temp(struct vn_cs_decoder * dec,VkRenderingInfo * val)2521 vn_decode_VkRenderingInfo_temp(struct vn_cs_decoder *dec, VkRenderingInfo *val)
2522 {
2523 VkStructureType stype;
2524 vn_decode_VkStructureType(dec, &stype);
2525 if (stype != VK_STRUCTURE_TYPE_RENDERING_INFO)
2526 vn_cs_decoder_set_fatal(dec);
2527
2528 val->sType = stype;
2529 val->pNext = vn_decode_VkRenderingInfo_pnext_temp(dec);
2530 vn_decode_VkRenderingInfo_self_temp(dec, val);
2531 }
2532
2533 static inline void
vn_replace_VkRenderingInfo_handle_self(VkRenderingInfo * val)2534 vn_replace_VkRenderingInfo_handle_self(VkRenderingInfo *val)
2535 {
2536 /* skip val->sType */
2537 /* skip val->pNext */
2538 /* skip val->flags */
2539 vn_replace_VkRect2D_handle(&val->renderArea);
2540 /* skip val->layerCount */
2541 /* skip val->viewMask */
2542 /* skip val->colorAttachmentCount */
2543 if (val->pColorAttachments) {
2544 for (uint32_t i = 0; i < val->colorAttachmentCount; i++)
2545 vn_replace_VkRenderingAttachmentInfo_handle(&((VkRenderingAttachmentInfo *)val->pColorAttachments)[i]);
2546 }
2547 if (val->pDepthAttachment)
2548 vn_replace_VkRenderingAttachmentInfo_handle((VkRenderingAttachmentInfo *)val->pDepthAttachment);
2549 if (val->pStencilAttachment)
2550 vn_replace_VkRenderingAttachmentInfo_handle((VkRenderingAttachmentInfo *)val->pStencilAttachment);
2551 }
2552
2553 static inline void
vn_replace_VkRenderingInfo_handle(VkRenderingInfo * val)2554 vn_replace_VkRenderingInfo_handle(VkRenderingInfo *val)
2555 {
2556 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2557
2558 do {
2559 switch ((int32_t)pnext->sType) {
2560 case VK_STRUCTURE_TYPE_RENDERING_INFO:
2561 vn_replace_VkRenderingInfo_handle_self((VkRenderingInfo *)pnext);
2562 break;
2563 case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
2564 vn_replace_VkDeviceGroupRenderPassBeginInfo_handle_self((VkDeviceGroupRenderPassBeginInfo *)pnext);
2565 break;
2566 default:
2567 /* ignore unknown/unsupported struct */
2568 break;
2569 }
2570 pnext = pnext->pNext;
2571 } while (pnext);
2572 }
2573
vn_decode_vkAllocateCommandBuffers_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkAllocateCommandBuffers * args)2574 static inline void vn_decode_vkAllocateCommandBuffers_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkAllocateCommandBuffers *args)
2575 {
2576 vn_decode_VkDevice_lookup(dec, &args->device);
2577 if (vn_decode_simple_pointer(dec)) {
2578 args->pAllocateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pAllocateInfo));
2579 if (!args->pAllocateInfo) return;
2580 vn_decode_VkCommandBufferAllocateInfo_temp(dec, (VkCommandBufferAllocateInfo *)args->pAllocateInfo);
2581 } else {
2582 args->pAllocateInfo = NULL;
2583 vn_cs_decoder_set_fatal(dec);
2584 }
2585 if (vn_peek_array_size(dec)) {
2586 const uint32_t iter_count = vn_decode_array_size(dec, (args->pAllocateInfo ? args->pAllocateInfo->commandBufferCount : 0));
2587 args->pCommandBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCommandBuffers) * iter_count);
2588 if (!args->pCommandBuffers) return;
2589 for (uint32_t i = 0; i < iter_count; i++)
2590 vn_decode_VkCommandBuffer_temp(dec, &args->pCommandBuffers[i]);
2591 } else {
2592 vn_decode_array_size(dec, (args->pAllocateInfo ? args->pAllocateInfo->commandBufferCount : 0));
2593 args->pCommandBuffers = NULL;
2594 }
2595 }
2596
vn_replace_vkAllocateCommandBuffers_args_handle(struct vn_command_vkAllocateCommandBuffers * args)2597 static inline void vn_replace_vkAllocateCommandBuffers_args_handle(struct vn_command_vkAllocateCommandBuffers *args)
2598 {
2599 vn_replace_VkDevice_handle(&args->device);
2600 if (args->pAllocateInfo)
2601 vn_replace_VkCommandBufferAllocateInfo_handle((VkCommandBufferAllocateInfo *)args->pAllocateInfo);
2602 /* skip args->pCommandBuffers */
2603 }
2604
vn_encode_vkAllocateCommandBuffers_reply(struct vn_cs_encoder * enc,const struct vn_command_vkAllocateCommandBuffers * args)2605 static inline void vn_encode_vkAllocateCommandBuffers_reply(struct vn_cs_encoder *enc, const struct vn_command_vkAllocateCommandBuffers *args)
2606 {
2607 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkAllocateCommandBuffers_EXT});
2608
2609 vn_encode_VkResult(enc, &args->ret);
2610 /* skip args->device */
2611 /* skip args->pAllocateInfo */
2612 if (args->pCommandBuffers) {
2613 vn_encode_array_size(enc, (args->pAllocateInfo ? args->pAllocateInfo->commandBufferCount : 0));
2614 for (uint32_t i = 0; i < (args->pAllocateInfo ? args->pAllocateInfo->commandBufferCount : 0); i++)
2615 vn_encode_VkCommandBuffer(enc, &args->pCommandBuffers[i]);
2616 } else {
2617 vn_encode_array_size(enc, 0);
2618 }
2619 }
2620
vn_decode_vkFreeCommandBuffers_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkFreeCommandBuffers * args)2621 static inline void vn_decode_vkFreeCommandBuffers_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkFreeCommandBuffers *args)
2622 {
2623 vn_decode_VkDevice_lookup(dec, &args->device);
2624 vn_decode_VkCommandPool_lookup(dec, &args->commandPool);
2625 vn_decode_uint32_t(dec, &args->commandBufferCount);
2626 if (vn_peek_array_size(dec)) {
2627 const uint32_t iter_count = vn_decode_array_size(dec, args->commandBufferCount);
2628 args->pCommandBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCommandBuffers) * iter_count);
2629 if (!args->pCommandBuffers) return;
2630 for (uint32_t i = 0; i < iter_count; i++)
2631 vn_decode_VkCommandBuffer_lookup(dec, &((VkCommandBuffer *)args->pCommandBuffers)[i]);
2632 } else {
2633 vn_decode_array_size_unchecked(dec);
2634 args->pCommandBuffers = NULL;
2635 }
2636 }
2637
vn_replace_vkFreeCommandBuffers_args_handle(struct vn_command_vkFreeCommandBuffers * args)2638 static inline void vn_replace_vkFreeCommandBuffers_args_handle(struct vn_command_vkFreeCommandBuffers *args)
2639 {
2640 vn_replace_VkDevice_handle(&args->device);
2641 vn_replace_VkCommandPool_handle(&args->commandPool);
2642 /* skip args->commandBufferCount */
2643 if (args->pCommandBuffers) {
2644 for (uint32_t i = 0; i < args->commandBufferCount; i++)
2645 vn_replace_VkCommandBuffer_handle(&((VkCommandBuffer *)args->pCommandBuffers)[i]);
2646 }
2647 }
2648
vn_encode_vkFreeCommandBuffers_reply(struct vn_cs_encoder * enc,const struct vn_command_vkFreeCommandBuffers * args)2649 static inline void vn_encode_vkFreeCommandBuffers_reply(struct vn_cs_encoder *enc, const struct vn_command_vkFreeCommandBuffers *args)
2650 {
2651 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkFreeCommandBuffers_EXT});
2652
2653 /* skip args->device */
2654 /* skip args->commandPool */
2655 /* skip args->commandBufferCount */
2656 /* skip args->pCommandBuffers */
2657 }
2658
vn_decode_vkBeginCommandBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkBeginCommandBuffer * args)2659 static inline void vn_decode_vkBeginCommandBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkBeginCommandBuffer *args)
2660 {
2661 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2662 if (vn_decode_simple_pointer(dec)) {
2663 args->pBeginInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBeginInfo));
2664 if (!args->pBeginInfo) return;
2665 vn_decode_VkCommandBufferBeginInfo_temp(dec, (VkCommandBufferBeginInfo *)args->pBeginInfo);
2666 } else {
2667 args->pBeginInfo = NULL;
2668 vn_cs_decoder_set_fatal(dec);
2669 }
2670 }
2671
vn_replace_vkBeginCommandBuffer_args_handle(struct vn_command_vkBeginCommandBuffer * args)2672 static inline void vn_replace_vkBeginCommandBuffer_args_handle(struct vn_command_vkBeginCommandBuffer *args)
2673 {
2674 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2675 if (args->pBeginInfo)
2676 vn_replace_VkCommandBufferBeginInfo_handle((VkCommandBufferBeginInfo *)args->pBeginInfo);
2677 }
2678
vn_encode_vkBeginCommandBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkBeginCommandBuffer * args)2679 static inline void vn_encode_vkBeginCommandBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkBeginCommandBuffer *args)
2680 {
2681 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkBeginCommandBuffer_EXT});
2682
2683 vn_encode_VkResult(enc, &args->ret);
2684 /* skip args->commandBuffer */
2685 /* skip args->pBeginInfo */
2686 }
2687
vn_decode_vkEndCommandBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkEndCommandBuffer * args)2688 static inline void vn_decode_vkEndCommandBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkEndCommandBuffer *args)
2689 {
2690 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2691 }
2692
vn_replace_vkEndCommandBuffer_args_handle(struct vn_command_vkEndCommandBuffer * args)2693 static inline void vn_replace_vkEndCommandBuffer_args_handle(struct vn_command_vkEndCommandBuffer *args)
2694 {
2695 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2696 }
2697
vn_encode_vkEndCommandBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkEndCommandBuffer * args)2698 static inline void vn_encode_vkEndCommandBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkEndCommandBuffer *args)
2699 {
2700 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkEndCommandBuffer_EXT});
2701
2702 vn_encode_VkResult(enc, &args->ret);
2703 /* skip args->commandBuffer */
2704 }
2705
vn_decode_vkResetCommandBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkResetCommandBuffer * args)2706 static inline void vn_decode_vkResetCommandBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkResetCommandBuffer *args)
2707 {
2708 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2709 vn_decode_VkFlags(dec, &args->flags);
2710 }
2711
vn_replace_vkResetCommandBuffer_args_handle(struct vn_command_vkResetCommandBuffer * args)2712 static inline void vn_replace_vkResetCommandBuffer_args_handle(struct vn_command_vkResetCommandBuffer *args)
2713 {
2714 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2715 /* skip args->flags */
2716 }
2717
vn_encode_vkResetCommandBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkResetCommandBuffer * args)2718 static inline void vn_encode_vkResetCommandBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkResetCommandBuffer *args)
2719 {
2720 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkResetCommandBuffer_EXT});
2721
2722 vn_encode_VkResult(enc, &args->ret);
2723 /* skip args->commandBuffer */
2724 /* skip args->flags */
2725 }
2726
vn_decode_vkCmdBindPipeline_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBindPipeline * args)2727 static inline void vn_decode_vkCmdBindPipeline_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindPipeline *args)
2728 {
2729 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2730 vn_decode_VkPipelineBindPoint(dec, &args->pipelineBindPoint);
2731 vn_decode_VkPipeline_lookup(dec, &args->pipeline);
2732 }
2733
vn_replace_vkCmdBindPipeline_args_handle(struct vn_command_vkCmdBindPipeline * args)2734 static inline void vn_replace_vkCmdBindPipeline_args_handle(struct vn_command_vkCmdBindPipeline *args)
2735 {
2736 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2737 /* skip args->pipelineBindPoint */
2738 vn_replace_VkPipeline_handle(&args->pipeline);
2739 }
2740
vn_encode_vkCmdBindPipeline_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBindPipeline * args)2741 static inline void vn_encode_vkCmdBindPipeline_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindPipeline *args)
2742 {
2743 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindPipeline_EXT});
2744
2745 /* skip args->commandBuffer */
2746 /* skip args->pipelineBindPoint */
2747 /* skip args->pipeline */
2748 }
2749
vn_decode_vkCmdSetViewport_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetViewport * args)2750 static inline void vn_decode_vkCmdSetViewport_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetViewport *args)
2751 {
2752 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2753 vn_decode_uint32_t(dec, &args->firstViewport);
2754 vn_decode_uint32_t(dec, &args->viewportCount);
2755 if (vn_peek_array_size(dec)) {
2756 const uint32_t iter_count = vn_decode_array_size(dec, args->viewportCount);
2757 args->pViewports = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pViewports) * iter_count);
2758 if (!args->pViewports) return;
2759 for (uint32_t i = 0; i < iter_count; i++)
2760 vn_decode_VkViewport_temp(dec, &((VkViewport *)args->pViewports)[i]);
2761 } else {
2762 vn_decode_array_size(dec, args->viewportCount);
2763 args->pViewports = NULL;
2764 }
2765 }
2766
vn_replace_vkCmdSetViewport_args_handle(struct vn_command_vkCmdSetViewport * args)2767 static inline void vn_replace_vkCmdSetViewport_args_handle(struct vn_command_vkCmdSetViewport *args)
2768 {
2769 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2770 /* skip args->firstViewport */
2771 /* skip args->viewportCount */
2772 if (args->pViewports) {
2773 for (uint32_t i = 0; i < args->viewportCount; i++)
2774 vn_replace_VkViewport_handle(&((VkViewport *)args->pViewports)[i]);
2775 }
2776 }
2777
vn_encode_vkCmdSetViewport_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetViewport * args)2778 static inline void vn_encode_vkCmdSetViewport_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetViewport *args)
2779 {
2780 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetViewport_EXT});
2781
2782 /* skip args->commandBuffer */
2783 /* skip args->firstViewport */
2784 /* skip args->viewportCount */
2785 /* skip args->pViewports */
2786 }
2787
vn_decode_vkCmdSetScissor_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetScissor * args)2788 static inline void vn_decode_vkCmdSetScissor_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetScissor *args)
2789 {
2790 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2791 vn_decode_uint32_t(dec, &args->firstScissor);
2792 vn_decode_uint32_t(dec, &args->scissorCount);
2793 if (vn_peek_array_size(dec)) {
2794 const uint32_t iter_count = vn_decode_array_size(dec, args->scissorCount);
2795 args->pScissors = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pScissors) * iter_count);
2796 if (!args->pScissors) return;
2797 for (uint32_t i = 0; i < iter_count; i++)
2798 vn_decode_VkRect2D_temp(dec, &((VkRect2D *)args->pScissors)[i]);
2799 } else {
2800 vn_decode_array_size(dec, args->scissorCount);
2801 args->pScissors = NULL;
2802 }
2803 }
2804
vn_replace_vkCmdSetScissor_args_handle(struct vn_command_vkCmdSetScissor * args)2805 static inline void vn_replace_vkCmdSetScissor_args_handle(struct vn_command_vkCmdSetScissor *args)
2806 {
2807 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2808 /* skip args->firstScissor */
2809 /* skip args->scissorCount */
2810 if (args->pScissors) {
2811 for (uint32_t i = 0; i < args->scissorCount; i++)
2812 vn_replace_VkRect2D_handle(&((VkRect2D *)args->pScissors)[i]);
2813 }
2814 }
2815
vn_encode_vkCmdSetScissor_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetScissor * args)2816 static inline void vn_encode_vkCmdSetScissor_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetScissor *args)
2817 {
2818 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetScissor_EXT});
2819
2820 /* skip args->commandBuffer */
2821 /* skip args->firstScissor */
2822 /* skip args->scissorCount */
2823 /* skip args->pScissors */
2824 }
2825
vn_decode_vkCmdSetLineWidth_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetLineWidth * args)2826 static inline void vn_decode_vkCmdSetLineWidth_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetLineWidth *args)
2827 {
2828 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2829 vn_decode_float(dec, &args->lineWidth);
2830 }
2831
vn_replace_vkCmdSetLineWidth_args_handle(struct vn_command_vkCmdSetLineWidth * args)2832 static inline void vn_replace_vkCmdSetLineWidth_args_handle(struct vn_command_vkCmdSetLineWidth *args)
2833 {
2834 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2835 /* skip args->lineWidth */
2836 }
2837
vn_encode_vkCmdSetLineWidth_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetLineWidth * args)2838 static inline void vn_encode_vkCmdSetLineWidth_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetLineWidth *args)
2839 {
2840 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetLineWidth_EXT});
2841
2842 /* skip args->commandBuffer */
2843 /* skip args->lineWidth */
2844 }
2845
vn_decode_vkCmdSetDepthBias_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDepthBias * args)2846 static inline void vn_decode_vkCmdSetDepthBias_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthBias *args)
2847 {
2848 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2849 vn_decode_float(dec, &args->depthBiasConstantFactor);
2850 vn_decode_float(dec, &args->depthBiasClamp);
2851 vn_decode_float(dec, &args->depthBiasSlopeFactor);
2852 }
2853
vn_replace_vkCmdSetDepthBias_args_handle(struct vn_command_vkCmdSetDepthBias * args)2854 static inline void vn_replace_vkCmdSetDepthBias_args_handle(struct vn_command_vkCmdSetDepthBias *args)
2855 {
2856 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2857 /* skip args->depthBiasConstantFactor */
2858 /* skip args->depthBiasClamp */
2859 /* skip args->depthBiasSlopeFactor */
2860 }
2861
vn_encode_vkCmdSetDepthBias_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDepthBias * args)2862 static inline void vn_encode_vkCmdSetDepthBias_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthBias *args)
2863 {
2864 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthBias_EXT});
2865
2866 /* skip args->commandBuffer */
2867 /* skip args->depthBiasConstantFactor */
2868 /* skip args->depthBiasClamp */
2869 /* skip args->depthBiasSlopeFactor */
2870 }
2871
vn_decode_vkCmdSetBlendConstants_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetBlendConstants * args)2872 static inline void vn_decode_vkCmdSetBlendConstants_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetBlendConstants *args)
2873 {
2874 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2875 {
2876 const size_t array_size = vn_decode_array_size(dec, 4);
2877 vn_decode_float_array(dec, (float *)args->blendConstants, array_size);
2878 }
2879 }
2880
vn_replace_vkCmdSetBlendConstants_args_handle(struct vn_command_vkCmdSetBlendConstants * args)2881 static inline void vn_replace_vkCmdSetBlendConstants_args_handle(struct vn_command_vkCmdSetBlendConstants *args)
2882 {
2883 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2884 /* skip args->blendConstants */
2885 }
2886
vn_encode_vkCmdSetBlendConstants_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetBlendConstants * args)2887 static inline void vn_encode_vkCmdSetBlendConstants_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetBlendConstants *args)
2888 {
2889 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetBlendConstants_EXT});
2890
2891 /* skip args->commandBuffer */
2892 /* skip args->blendConstants */
2893 }
2894
vn_decode_vkCmdSetDepthBounds_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDepthBounds * args)2895 static inline void vn_decode_vkCmdSetDepthBounds_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthBounds *args)
2896 {
2897 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2898 vn_decode_float(dec, &args->minDepthBounds);
2899 vn_decode_float(dec, &args->maxDepthBounds);
2900 }
2901
vn_replace_vkCmdSetDepthBounds_args_handle(struct vn_command_vkCmdSetDepthBounds * args)2902 static inline void vn_replace_vkCmdSetDepthBounds_args_handle(struct vn_command_vkCmdSetDepthBounds *args)
2903 {
2904 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2905 /* skip args->minDepthBounds */
2906 /* skip args->maxDepthBounds */
2907 }
2908
vn_encode_vkCmdSetDepthBounds_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDepthBounds * args)2909 static inline void vn_encode_vkCmdSetDepthBounds_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthBounds *args)
2910 {
2911 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthBounds_EXT});
2912
2913 /* skip args->commandBuffer */
2914 /* skip args->minDepthBounds */
2915 /* skip args->maxDepthBounds */
2916 }
2917
vn_decode_vkCmdSetStencilCompareMask_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetStencilCompareMask * args)2918 static inline void vn_decode_vkCmdSetStencilCompareMask_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilCompareMask *args)
2919 {
2920 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2921 vn_decode_VkFlags(dec, &args->faceMask);
2922 vn_decode_uint32_t(dec, &args->compareMask);
2923 }
2924
vn_replace_vkCmdSetStencilCompareMask_args_handle(struct vn_command_vkCmdSetStencilCompareMask * args)2925 static inline void vn_replace_vkCmdSetStencilCompareMask_args_handle(struct vn_command_vkCmdSetStencilCompareMask *args)
2926 {
2927 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2928 /* skip args->faceMask */
2929 /* skip args->compareMask */
2930 }
2931
vn_encode_vkCmdSetStencilCompareMask_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetStencilCompareMask * args)2932 static inline void vn_encode_vkCmdSetStencilCompareMask_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilCompareMask *args)
2933 {
2934 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilCompareMask_EXT});
2935
2936 /* skip args->commandBuffer */
2937 /* skip args->faceMask */
2938 /* skip args->compareMask */
2939 }
2940
vn_decode_vkCmdSetStencilWriteMask_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetStencilWriteMask * args)2941 static inline void vn_decode_vkCmdSetStencilWriteMask_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilWriteMask *args)
2942 {
2943 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2944 vn_decode_VkFlags(dec, &args->faceMask);
2945 vn_decode_uint32_t(dec, &args->writeMask);
2946 }
2947
vn_replace_vkCmdSetStencilWriteMask_args_handle(struct vn_command_vkCmdSetStencilWriteMask * args)2948 static inline void vn_replace_vkCmdSetStencilWriteMask_args_handle(struct vn_command_vkCmdSetStencilWriteMask *args)
2949 {
2950 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2951 /* skip args->faceMask */
2952 /* skip args->writeMask */
2953 }
2954
vn_encode_vkCmdSetStencilWriteMask_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetStencilWriteMask * args)2955 static inline void vn_encode_vkCmdSetStencilWriteMask_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilWriteMask *args)
2956 {
2957 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilWriteMask_EXT});
2958
2959 /* skip args->commandBuffer */
2960 /* skip args->faceMask */
2961 /* skip args->writeMask */
2962 }
2963
vn_decode_vkCmdSetStencilReference_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetStencilReference * args)2964 static inline void vn_decode_vkCmdSetStencilReference_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilReference *args)
2965 {
2966 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2967 vn_decode_VkFlags(dec, &args->faceMask);
2968 vn_decode_uint32_t(dec, &args->reference);
2969 }
2970
vn_replace_vkCmdSetStencilReference_args_handle(struct vn_command_vkCmdSetStencilReference * args)2971 static inline void vn_replace_vkCmdSetStencilReference_args_handle(struct vn_command_vkCmdSetStencilReference *args)
2972 {
2973 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
2974 /* skip args->faceMask */
2975 /* skip args->reference */
2976 }
2977
vn_encode_vkCmdSetStencilReference_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetStencilReference * args)2978 static inline void vn_encode_vkCmdSetStencilReference_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilReference *args)
2979 {
2980 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilReference_EXT});
2981
2982 /* skip args->commandBuffer */
2983 /* skip args->faceMask */
2984 /* skip args->reference */
2985 }
2986
vn_decode_vkCmdBindDescriptorSets_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBindDescriptorSets * args)2987 static inline void vn_decode_vkCmdBindDescriptorSets_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindDescriptorSets *args)
2988 {
2989 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
2990 vn_decode_VkPipelineBindPoint(dec, &args->pipelineBindPoint);
2991 vn_decode_VkPipelineLayout_lookup(dec, &args->layout);
2992 vn_decode_uint32_t(dec, &args->firstSet);
2993 vn_decode_uint32_t(dec, &args->descriptorSetCount);
2994 if (vn_peek_array_size(dec)) {
2995 const uint32_t iter_count = vn_decode_array_size(dec, args->descriptorSetCount);
2996 args->pDescriptorSets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDescriptorSets) * iter_count);
2997 if (!args->pDescriptorSets) return;
2998 for (uint32_t i = 0; i < iter_count; i++)
2999 vn_decode_VkDescriptorSet_lookup(dec, &((VkDescriptorSet *)args->pDescriptorSets)[i]);
3000 } else {
3001 vn_decode_array_size(dec, args->descriptorSetCount);
3002 args->pDescriptorSets = NULL;
3003 }
3004 vn_decode_uint32_t(dec, &args->dynamicOffsetCount);
3005 if (vn_peek_array_size(dec)) {
3006 const size_t array_size = vn_decode_array_size(dec, args->dynamicOffsetCount);
3007 args->pDynamicOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDynamicOffsets) * array_size);
3008 if (!args->pDynamicOffsets) return;
3009 vn_decode_uint32_t_array(dec, (uint32_t *)args->pDynamicOffsets, array_size);
3010 } else {
3011 vn_decode_array_size(dec, args->dynamicOffsetCount);
3012 args->pDynamicOffsets = NULL;
3013 }
3014 }
3015
vn_replace_vkCmdBindDescriptorSets_args_handle(struct vn_command_vkCmdBindDescriptorSets * args)3016 static inline void vn_replace_vkCmdBindDescriptorSets_args_handle(struct vn_command_vkCmdBindDescriptorSets *args)
3017 {
3018 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3019 /* skip args->pipelineBindPoint */
3020 vn_replace_VkPipelineLayout_handle(&args->layout);
3021 /* skip args->firstSet */
3022 /* skip args->descriptorSetCount */
3023 if (args->pDescriptorSets) {
3024 for (uint32_t i = 0; i < args->descriptorSetCount; i++)
3025 vn_replace_VkDescriptorSet_handle(&((VkDescriptorSet *)args->pDescriptorSets)[i]);
3026 }
3027 /* skip args->dynamicOffsetCount */
3028 /* skip args->pDynamicOffsets */
3029 }
3030
vn_encode_vkCmdBindDescriptorSets_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBindDescriptorSets * args)3031 static inline void vn_encode_vkCmdBindDescriptorSets_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindDescriptorSets *args)
3032 {
3033 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindDescriptorSets_EXT});
3034
3035 /* skip args->commandBuffer */
3036 /* skip args->pipelineBindPoint */
3037 /* skip args->layout */
3038 /* skip args->firstSet */
3039 /* skip args->descriptorSetCount */
3040 /* skip args->pDescriptorSets */
3041 /* skip args->dynamicOffsetCount */
3042 /* skip args->pDynamicOffsets */
3043 }
3044
vn_decode_vkCmdBindIndexBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBindIndexBuffer * args)3045 static inline void vn_decode_vkCmdBindIndexBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindIndexBuffer *args)
3046 {
3047 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3048 vn_decode_VkBuffer_lookup(dec, &args->buffer);
3049 vn_decode_VkDeviceSize(dec, &args->offset);
3050 vn_decode_VkIndexType(dec, &args->indexType);
3051 }
3052
vn_replace_vkCmdBindIndexBuffer_args_handle(struct vn_command_vkCmdBindIndexBuffer * args)3053 static inline void vn_replace_vkCmdBindIndexBuffer_args_handle(struct vn_command_vkCmdBindIndexBuffer *args)
3054 {
3055 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3056 vn_replace_VkBuffer_handle(&args->buffer);
3057 /* skip args->offset */
3058 /* skip args->indexType */
3059 }
3060
vn_encode_vkCmdBindIndexBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBindIndexBuffer * args)3061 static inline void vn_encode_vkCmdBindIndexBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindIndexBuffer *args)
3062 {
3063 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindIndexBuffer_EXT});
3064
3065 /* skip args->commandBuffer */
3066 /* skip args->buffer */
3067 /* skip args->offset */
3068 /* skip args->indexType */
3069 }
3070
vn_decode_vkCmdBindVertexBuffers_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBindVertexBuffers * args)3071 static inline void vn_decode_vkCmdBindVertexBuffers_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindVertexBuffers *args)
3072 {
3073 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3074 vn_decode_uint32_t(dec, &args->firstBinding);
3075 vn_decode_uint32_t(dec, &args->bindingCount);
3076 if (vn_peek_array_size(dec)) {
3077 const uint32_t iter_count = vn_decode_array_size(dec, args->bindingCount);
3078 args->pBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBuffers) * iter_count);
3079 if (!args->pBuffers) return;
3080 for (uint32_t i = 0; i < iter_count; i++)
3081 vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pBuffers)[i]);
3082 } else {
3083 vn_decode_array_size(dec, args->bindingCount);
3084 args->pBuffers = NULL;
3085 }
3086 if (vn_peek_array_size(dec)) {
3087 const size_t array_size = vn_decode_array_size(dec, args->bindingCount);
3088 args->pOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pOffsets) * array_size);
3089 if (!args->pOffsets) return;
3090 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pOffsets, array_size);
3091 } else {
3092 vn_decode_array_size(dec, args->bindingCount);
3093 args->pOffsets = NULL;
3094 }
3095 }
3096
vn_replace_vkCmdBindVertexBuffers_args_handle(struct vn_command_vkCmdBindVertexBuffers * args)3097 static inline void vn_replace_vkCmdBindVertexBuffers_args_handle(struct vn_command_vkCmdBindVertexBuffers *args)
3098 {
3099 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3100 /* skip args->firstBinding */
3101 /* skip args->bindingCount */
3102 if (args->pBuffers) {
3103 for (uint32_t i = 0; i < args->bindingCount; i++)
3104 vn_replace_VkBuffer_handle(&((VkBuffer *)args->pBuffers)[i]);
3105 }
3106 /* skip args->pOffsets */
3107 }
3108
vn_encode_vkCmdBindVertexBuffers_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBindVertexBuffers * args)3109 static inline void vn_encode_vkCmdBindVertexBuffers_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindVertexBuffers *args)
3110 {
3111 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindVertexBuffers_EXT});
3112
3113 /* skip args->commandBuffer */
3114 /* skip args->firstBinding */
3115 /* skip args->bindingCount */
3116 /* skip args->pBuffers */
3117 /* skip args->pOffsets */
3118 }
3119
vn_decode_vkCmdDraw_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDraw * args)3120 static inline void vn_decode_vkCmdDraw_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDraw *args)
3121 {
3122 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3123 vn_decode_uint32_t(dec, &args->vertexCount);
3124 vn_decode_uint32_t(dec, &args->instanceCount);
3125 vn_decode_uint32_t(dec, &args->firstVertex);
3126 vn_decode_uint32_t(dec, &args->firstInstance);
3127 }
3128
vn_replace_vkCmdDraw_args_handle(struct vn_command_vkCmdDraw * args)3129 static inline void vn_replace_vkCmdDraw_args_handle(struct vn_command_vkCmdDraw *args)
3130 {
3131 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3132 /* skip args->vertexCount */
3133 /* skip args->instanceCount */
3134 /* skip args->firstVertex */
3135 /* skip args->firstInstance */
3136 }
3137
vn_encode_vkCmdDraw_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDraw * args)3138 static inline void vn_encode_vkCmdDraw_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDraw *args)
3139 {
3140 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDraw_EXT});
3141
3142 /* skip args->commandBuffer */
3143 /* skip args->vertexCount */
3144 /* skip args->instanceCount */
3145 /* skip args->firstVertex */
3146 /* skip args->firstInstance */
3147 }
3148
vn_decode_vkCmdDrawIndexed_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawIndexed * args)3149 static inline void vn_decode_vkCmdDrawIndexed_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndexed *args)
3150 {
3151 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3152 vn_decode_uint32_t(dec, &args->indexCount);
3153 vn_decode_uint32_t(dec, &args->instanceCount);
3154 vn_decode_uint32_t(dec, &args->firstIndex);
3155 vn_decode_int32_t(dec, &args->vertexOffset);
3156 vn_decode_uint32_t(dec, &args->firstInstance);
3157 }
3158
vn_replace_vkCmdDrawIndexed_args_handle(struct vn_command_vkCmdDrawIndexed * args)3159 static inline void vn_replace_vkCmdDrawIndexed_args_handle(struct vn_command_vkCmdDrawIndexed *args)
3160 {
3161 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3162 /* skip args->indexCount */
3163 /* skip args->instanceCount */
3164 /* skip args->firstIndex */
3165 /* skip args->vertexOffset */
3166 /* skip args->firstInstance */
3167 }
3168
vn_encode_vkCmdDrawIndexed_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawIndexed * args)3169 static inline void vn_encode_vkCmdDrawIndexed_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndexed *args)
3170 {
3171 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndexed_EXT});
3172
3173 /* skip args->commandBuffer */
3174 /* skip args->indexCount */
3175 /* skip args->instanceCount */
3176 /* skip args->firstIndex */
3177 /* skip args->vertexOffset */
3178 /* skip args->firstInstance */
3179 }
3180
vn_decode_vkCmdDrawMultiEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawMultiEXT * args)3181 static inline void vn_decode_vkCmdDrawMultiEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawMultiEXT *args)
3182 {
3183 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3184 vn_decode_uint32_t(dec, &args->drawCount);
3185 if (vn_peek_array_size(dec)) {
3186 const uint32_t iter_count = vn_decode_array_size(dec, args->drawCount);
3187 args->pVertexInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pVertexInfo) * iter_count);
3188 if (!args->pVertexInfo) return;
3189 for (uint32_t i = 0; i < iter_count; i++)
3190 vn_decode_VkMultiDrawInfoEXT_temp(dec, &((VkMultiDrawInfoEXT *)args->pVertexInfo)[i]);
3191 } else {
3192 vn_decode_array_size_unchecked(dec);
3193 args->pVertexInfo = NULL;
3194 }
3195 vn_decode_uint32_t(dec, &args->instanceCount);
3196 vn_decode_uint32_t(dec, &args->firstInstance);
3197 vn_decode_uint32_t(dec, &args->stride);
3198 }
3199
vn_replace_vkCmdDrawMultiEXT_args_handle(struct vn_command_vkCmdDrawMultiEXT * args)3200 static inline void vn_replace_vkCmdDrawMultiEXT_args_handle(struct vn_command_vkCmdDrawMultiEXT *args)
3201 {
3202 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3203 /* skip args->drawCount */
3204 if (args->pVertexInfo) {
3205 for (uint32_t i = 0; i < args->drawCount; i++)
3206 vn_replace_VkMultiDrawInfoEXT_handle(&((VkMultiDrawInfoEXT *)args->pVertexInfo)[i]);
3207 }
3208 /* skip args->instanceCount */
3209 /* skip args->firstInstance */
3210 /* skip args->stride */
3211 }
3212
vn_encode_vkCmdDrawMultiEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawMultiEXT * args)3213 static inline void vn_encode_vkCmdDrawMultiEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawMultiEXT *args)
3214 {
3215 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawMultiEXT_EXT});
3216
3217 /* skip args->commandBuffer */
3218 /* skip args->drawCount */
3219 /* skip args->pVertexInfo */
3220 /* skip args->instanceCount */
3221 /* skip args->firstInstance */
3222 /* skip args->stride */
3223 }
3224
vn_decode_vkCmdDrawMultiIndexedEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawMultiIndexedEXT * args)3225 static inline void vn_decode_vkCmdDrawMultiIndexedEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawMultiIndexedEXT *args)
3226 {
3227 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3228 vn_decode_uint32_t(dec, &args->drawCount);
3229 if (vn_peek_array_size(dec)) {
3230 const uint32_t iter_count = vn_decode_array_size(dec, args->drawCount);
3231 args->pIndexInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pIndexInfo) * iter_count);
3232 if (!args->pIndexInfo) return;
3233 for (uint32_t i = 0; i < iter_count; i++)
3234 vn_decode_VkMultiDrawIndexedInfoEXT_temp(dec, &((VkMultiDrawIndexedInfoEXT *)args->pIndexInfo)[i]);
3235 } else {
3236 vn_decode_array_size_unchecked(dec);
3237 args->pIndexInfo = NULL;
3238 }
3239 vn_decode_uint32_t(dec, &args->instanceCount);
3240 vn_decode_uint32_t(dec, &args->firstInstance);
3241 vn_decode_uint32_t(dec, &args->stride);
3242 if (vn_decode_simple_pointer(dec)) {
3243 args->pVertexOffset = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pVertexOffset));
3244 if (!args->pVertexOffset) return;
3245 vn_decode_int32_t(dec, (int32_t *)args->pVertexOffset);
3246 } else {
3247 args->pVertexOffset = NULL;
3248 }
3249 }
3250
vn_replace_vkCmdDrawMultiIndexedEXT_args_handle(struct vn_command_vkCmdDrawMultiIndexedEXT * args)3251 static inline void vn_replace_vkCmdDrawMultiIndexedEXT_args_handle(struct vn_command_vkCmdDrawMultiIndexedEXT *args)
3252 {
3253 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3254 /* skip args->drawCount */
3255 if (args->pIndexInfo) {
3256 for (uint32_t i = 0; i < args->drawCount; i++)
3257 vn_replace_VkMultiDrawIndexedInfoEXT_handle(&((VkMultiDrawIndexedInfoEXT *)args->pIndexInfo)[i]);
3258 }
3259 /* skip args->instanceCount */
3260 /* skip args->firstInstance */
3261 /* skip args->stride */
3262 /* skip args->pVertexOffset */
3263 }
3264
vn_encode_vkCmdDrawMultiIndexedEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawMultiIndexedEXT * args)3265 static inline void vn_encode_vkCmdDrawMultiIndexedEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawMultiIndexedEXT *args)
3266 {
3267 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawMultiIndexedEXT_EXT});
3268
3269 /* skip args->commandBuffer */
3270 /* skip args->drawCount */
3271 /* skip args->pIndexInfo */
3272 /* skip args->instanceCount */
3273 /* skip args->firstInstance */
3274 /* skip args->stride */
3275 /* skip args->pVertexOffset */
3276 }
3277
vn_decode_vkCmdDrawIndirect_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawIndirect * args)3278 static inline void vn_decode_vkCmdDrawIndirect_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndirect *args)
3279 {
3280 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3281 vn_decode_VkBuffer_lookup(dec, &args->buffer);
3282 vn_decode_VkDeviceSize(dec, &args->offset);
3283 vn_decode_uint32_t(dec, &args->drawCount);
3284 vn_decode_uint32_t(dec, &args->stride);
3285 }
3286
vn_replace_vkCmdDrawIndirect_args_handle(struct vn_command_vkCmdDrawIndirect * args)3287 static inline void vn_replace_vkCmdDrawIndirect_args_handle(struct vn_command_vkCmdDrawIndirect *args)
3288 {
3289 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3290 vn_replace_VkBuffer_handle(&args->buffer);
3291 /* skip args->offset */
3292 /* skip args->drawCount */
3293 /* skip args->stride */
3294 }
3295
vn_encode_vkCmdDrawIndirect_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawIndirect * args)3296 static inline void vn_encode_vkCmdDrawIndirect_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndirect *args)
3297 {
3298 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndirect_EXT});
3299
3300 /* skip args->commandBuffer */
3301 /* skip args->buffer */
3302 /* skip args->offset */
3303 /* skip args->drawCount */
3304 /* skip args->stride */
3305 }
3306
vn_decode_vkCmdDrawIndexedIndirect_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawIndexedIndirect * args)3307 static inline void vn_decode_vkCmdDrawIndexedIndirect_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndexedIndirect *args)
3308 {
3309 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3310 vn_decode_VkBuffer_lookup(dec, &args->buffer);
3311 vn_decode_VkDeviceSize(dec, &args->offset);
3312 vn_decode_uint32_t(dec, &args->drawCount);
3313 vn_decode_uint32_t(dec, &args->stride);
3314 }
3315
vn_replace_vkCmdDrawIndexedIndirect_args_handle(struct vn_command_vkCmdDrawIndexedIndirect * args)3316 static inline void vn_replace_vkCmdDrawIndexedIndirect_args_handle(struct vn_command_vkCmdDrawIndexedIndirect *args)
3317 {
3318 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3319 vn_replace_VkBuffer_handle(&args->buffer);
3320 /* skip args->offset */
3321 /* skip args->drawCount */
3322 /* skip args->stride */
3323 }
3324
vn_encode_vkCmdDrawIndexedIndirect_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawIndexedIndirect * args)3325 static inline void vn_encode_vkCmdDrawIndexedIndirect_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndexedIndirect *args)
3326 {
3327 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndexedIndirect_EXT});
3328
3329 /* skip args->commandBuffer */
3330 /* skip args->buffer */
3331 /* skip args->offset */
3332 /* skip args->drawCount */
3333 /* skip args->stride */
3334 }
3335
vn_decode_vkCmdDispatch_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDispatch * args)3336 static inline void vn_decode_vkCmdDispatch_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDispatch *args)
3337 {
3338 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3339 vn_decode_uint32_t(dec, &args->groupCountX);
3340 vn_decode_uint32_t(dec, &args->groupCountY);
3341 vn_decode_uint32_t(dec, &args->groupCountZ);
3342 }
3343
vn_replace_vkCmdDispatch_args_handle(struct vn_command_vkCmdDispatch * args)3344 static inline void vn_replace_vkCmdDispatch_args_handle(struct vn_command_vkCmdDispatch *args)
3345 {
3346 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3347 /* skip args->groupCountX */
3348 /* skip args->groupCountY */
3349 /* skip args->groupCountZ */
3350 }
3351
vn_encode_vkCmdDispatch_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDispatch * args)3352 static inline void vn_encode_vkCmdDispatch_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDispatch *args)
3353 {
3354 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDispatch_EXT});
3355
3356 /* skip args->commandBuffer */
3357 /* skip args->groupCountX */
3358 /* skip args->groupCountY */
3359 /* skip args->groupCountZ */
3360 }
3361
vn_decode_vkCmdDispatchIndirect_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDispatchIndirect * args)3362 static inline void vn_decode_vkCmdDispatchIndirect_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDispatchIndirect *args)
3363 {
3364 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3365 vn_decode_VkBuffer_lookup(dec, &args->buffer);
3366 vn_decode_VkDeviceSize(dec, &args->offset);
3367 }
3368
vn_replace_vkCmdDispatchIndirect_args_handle(struct vn_command_vkCmdDispatchIndirect * args)3369 static inline void vn_replace_vkCmdDispatchIndirect_args_handle(struct vn_command_vkCmdDispatchIndirect *args)
3370 {
3371 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3372 vn_replace_VkBuffer_handle(&args->buffer);
3373 /* skip args->offset */
3374 }
3375
vn_encode_vkCmdDispatchIndirect_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDispatchIndirect * args)3376 static inline void vn_encode_vkCmdDispatchIndirect_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDispatchIndirect *args)
3377 {
3378 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDispatchIndirect_EXT});
3379
3380 /* skip args->commandBuffer */
3381 /* skip args->buffer */
3382 /* skip args->offset */
3383 }
3384
vn_decode_vkCmdCopyBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyBuffer * args)3385 static inline void vn_decode_vkCmdCopyBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyBuffer *args)
3386 {
3387 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3388 vn_decode_VkBuffer_lookup(dec, &args->srcBuffer);
3389 vn_decode_VkBuffer_lookup(dec, &args->dstBuffer);
3390 vn_decode_uint32_t(dec, &args->regionCount);
3391 if (vn_peek_array_size(dec)) {
3392 const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount);
3393 args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count);
3394 if (!args->pRegions) return;
3395 for (uint32_t i = 0; i < iter_count; i++)
3396 vn_decode_VkBufferCopy_temp(dec, &((VkBufferCopy *)args->pRegions)[i]);
3397 } else {
3398 vn_decode_array_size(dec, args->regionCount);
3399 args->pRegions = NULL;
3400 }
3401 }
3402
vn_replace_vkCmdCopyBuffer_args_handle(struct vn_command_vkCmdCopyBuffer * args)3403 static inline void vn_replace_vkCmdCopyBuffer_args_handle(struct vn_command_vkCmdCopyBuffer *args)
3404 {
3405 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3406 vn_replace_VkBuffer_handle(&args->srcBuffer);
3407 vn_replace_VkBuffer_handle(&args->dstBuffer);
3408 /* skip args->regionCount */
3409 if (args->pRegions) {
3410 for (uint32_t i = 0; i < args->regionCount; i++)
3411 vn_replace_VkBufferCopy_handle(&((VkBufferCopy *)args->pRegions)[i]);
3412 }
3413 }
3414
vn_encode_vkCmdCopyBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyBuffer * args)3415 static inline void vn_encode_vkCmdCopyBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyBuffer *args)
3416 {
3417 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyBuffer_EXT});
3418
3419 /* skip args->commandBuffer */
3420 /* skip args->srcBuffer */
3421 /* skip args->dstBuffer */
3422 /* skip args->regionCount */
3423 /* skip args->pRegions */
3424 }
3425
vn_decode_vkCmdCopyImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyImage * args)3426 static inline void vn_decode_vkCmdCopyImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyImage *args)
3427 {
3428 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3429 vn_decode_VkImage_lookup(dec, &args->srcImage);
3430 vn_decode_VkImageLayout(dec, &args->srcImageLayout);
3431 vn_decode_VkImage_lookup(dec, &args->dstImage);
3432 vn_decode_VkImageLayout(dec, &args->dstImageLayout);
3433 vn_decode_uint32_t(dec, &args->regionCount);
3434 if (vn_peek_array_size(dec)) {
3435 const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount);
3436 args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count);
3437 if (!args->pRegions) return;
3438 for (uint32_t i = 0; i < iter_count; i++)
3439 vn_decode_VkImageCopy_temp(dec, &((VkImageCopy *)args->pRegions)[i]);
3440 } else {
3441 vn_decode_array_size(dec, args->regionCount);
3442 args->pRegions = NULL;
3443 }
3444 }
3445
vn_replace_vkCmdCopyImage_args_handle(struct vn_command_vkCmdCopyImage * args)3446 static inline void vn_replace_vkCmdCopyImage_args_handle(struct vn_command_vkCmdCopyImage *args)
3447 {
3448 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3449 vn_replace_VkImage_handle(&args->srcImage);
3450 /* skip args->srcImageLayout */
3451 vn_replace_VkImage_handle(&args->dstImage);
3452 /* skip args->dstImageLayout */
3453 /* skip args->regionCount */
3454 if (args->pRegions) {
3455 for (uint32_t i = 0; i < args->regionCount; i++)
3456 vn_replace_VkImageCopy_handle(&((VkImageCopy *)args->pRegions)[i]);
3457 }
3458 }
3459
vn_encode_vkCmdCopyImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyImage * args)3460 static inline void vn_encode_vkCmdCopyImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyImage *args)
3461 {
3462 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyImage_EXT});
3463
3464 /* skip args->commandBuffer */
3465 /* skip args->srcImage */
3466 /* skip args->srcImageLayout */
3467 /* skip args->dstImage */
3468 /* skip args->dstImageLayout */
3469 /* skip args->regionCount */
3470 /* skip args->pRegions */
3471 }
3472
vn_decode_vkCmdBlitImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBlitImage * args)3473 static inline void vn_decode_vkCmdBlitImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBlitImage *args)
3474 {
3475 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3476 vn_decode_VkImage_lookup(dec, &args->srcImage);
3477 vn_decode_VkImageLayout(dec, &args->srcImageLayout);
3478 vn_decode_VkImage_lookup(dec, &args->dstImage);
3479 vn_decode_VkImageLayout(dec, &args->dstImageLayout);
3480 vn_decode_uint32_t(dec, &args->regionCount);
3481 if (vn_peek_array_size(dec)) {
3482 const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount);
3483 args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count);
3484 if (!args->pRegions) return;
3485 for (uint32_t i = 0; i < iter_count; i++)
3486 vn_decode_VkImageBlit_temp(dec, &((VkImageBlit *)args->pRegions)[i]);
3487 } else {
3488 vn_decode_array_size(dec, args->regionCount);
3489 args->pRegions = NULL;
3490 }
3491 vn_decode_VkFilter(dec, &args->filter);
3492 }
3493
vn_replace_vkCmdBlitImage_args_handle(struct vn_command_vkCmdBlitImage * args)3494 static inline void vn_replace_vkCmdBlitImage_args_handle(struct vn_command_vkCmdBlitImage *args)
3495 {
3496 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3497 vn_replace_VkImage_handle(&args->srcImage);
3498 /* skip args->srcImageLayout */
3499 vn_replace_VkImage_handle(&args->dstImage);
3500 /* skip args->dstImageLayout */
3501 /* skip args->regionCount */
3502 if (args->pRegions) {
3503 for (uint32_t i = 0; i < args->regionCount; i++)
3504 vn_replace_VkImageBlit_handle(&((VkImageBlit *)args->pRegions)[i]);
3505 }
3506 /* skip args->filter */
3507 }
3508
vn_encode_vkCmdBlitImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBlitImage * args)3509 static inline void vn_encode_vkCmdBlitImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBlitImage *args)
3510 {
3511 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBlitImage_EXT});
3512
3513 /* skip args->commandBuffer */
3514 /* skip args->srcImage */
3515 /* skip args->srcImageLayout */
3516 /* skip args->dstImage */
3517 /* skip args->dstImageLayout */
3518 /* skip args->regionCount */
3519 /* skip args->pRegions */
3520 /* skip args->filter */
3521 }
3522
vn_decode_vkCmdCopyBufferToImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyBufferToImage * args)3523 static inline void vn_decode_vkCmdCopyBufferToImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyBufferToImage *args)
3524 {
3525 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3526 vn_decode_VkBuffer_lookup(dec, &args->srcBuffer);
3527 vn_decode_VkImage_lookup(dec, &args->dstImage);
3528 vn_decode_VkImageLayout(dec, &args->dstImageLayout);
3529 vn_decode_uint32_t(dec, &args->regionCount);
3530 if (vn_peek_array_size(dec)) {
3531 const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount);
3532 args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count);
3533 if (!args->pRegions) return;
3534 for (uint32_t i = 0; i < iter_count; i++)
3535 vn_decode_VkBufferImageCopy_temp(dec, &((VkBufferImageCopy *)args->pRegions)[i]);
3536 } else {
3537 vn_decode_array_size(dec, args->regionCount);
3538 args->pRegions = NULL;
3539 }
3540 }
3541
vn_replace_vkCmdCopyBufferToImage_args_handle(struct vn_command_vkCmdCopyBufferToImage * args)3542 static inline void vn_replace_vkCmdCopyBufferToImage_args_handle(struct vn_command_vkCmdCopyBufferToImage *args)
3543 {
3544 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3545 vn_replace_VkBuffer_handle(&args->srcBuffer);
3546 vn_replace_VkImage_handle(&args->dstImage);
3547 /* skip args->dstImageLayout */
3548 /* skip args->regionCount */
3549 if (args->pRegions) {
3550 for (uint32_t i = 0; i < args->regionCount; i++)
3551 vn_replace_VkBufferImageCopy_handle(&((VkBufferImageCopy *)args->pRegions)[i]);
3552 }
3553 }
3554
vn_encode_vkCmdCopyBufferToImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyBufferToImage * args)3555 static inline void vn_encode_vkCmdCopyBufferToImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyBufferToImage *args)
3556 {
3557 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyBufferToImage_EXT});
3558
3559 /* skip args->commandBuffer */
3560 /* skip args->srcBuffer */
3561 /* skip args->dstImage */
3562 /* skip args->dstImageLayout */
3563 /* skip args->regionCount */
3564 /* skip args->pRegions */
3565 }
3566
vn_decode_vkCmdCopyImageToBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyImageToBuffer * args)3567 static inline void vn_decode_vkCmdCopyImageToBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyImageToBuffer *args)
3568 {
3569 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3570 vn_decode_VkImage_lookup(dec, &args->srcImage);
3571 vn_decode_VkImageLayout(dec, &args->srcImageLayout);
3572 vn_decode_VkBuffer_lookup(dec, &args->dstBuffer);
3573 vn_decode_uint32_t(dec, &args->regionCount);
3574 if (vn_peek_array_size(dec)) {
3575 const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount);
3576 args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count);
3577 if (!args->pRegions) return;
3578 for (uint32_t i = 0; i < iter_count; i++)
3579 vn_decode_VkBufferImageCopy_temp(dec, &((VkBufferImageCopy *)args->pRegions)[i]);
3580 } else {
3581 vn_decode_array_size(dec, args->regionCount);
3582 args->pRegions = NULL;
3583 }
3584 }
3585
vn_replace_vkCmdCopyImageToBuffer_args_handle(struct vn_command_vkCmdCopyImageToBuffer * args)3586 static inline void vn_replace_vkCmdCopyImageToBuffer_args_handle(struct vn_command_vkCmdCopyImageToBuffer *args)
3587 {
3588 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3589 vn_replace_VkImage_handle(&args->srcImage);
3590 /* skip args->srcImageLayout */
3591 vn_replace_VkBuffer_handle(&args->dstBuffer);
3592 /* skip args->regionCount */
3593 if (args->pRegions) {
3594 for (uint32_t i = 0; i < args->regionCount; i++)
3595 vn_replace_VkBufferImageCopy_handle(&((VkBufferImageCopy *)args->pRegions)[i]);
3596 }
3597 }
3598
vn_encode_vkCmdCopyImageToBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyImageToBuffer * args)3599 static inline void vn_encode_vkCmdCopyImageToBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyImageToBuffer *args)
3600 {
3601 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyImageToBuffer_EXT});
3602
3603 /* skip args->commandBuffer */
3604 /* skip args->srcImage */
3605 /* skip args->srcImageLayout */
3606 /* skip args->dstBuffer */
3607 /* skip args->regionCount */
3608 /* skip args->pRegions */
3609 }
3610
vn_decode_vkCmdUpdateBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdUpdateBuffer * args)3611 static inline void vn_decode_vkCmdUpdateBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdUpdateBuffer *args)
3612 {
3613 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3614 vn_decode_VkBuffer_lookup(dec, &args->dstBuffer);
3615 vn_decode_VkDeviceSize(dec, &args->dstOffset);
3616 vn_decode_VkDeviceSize(dec, &args->dataSize);
3617 if (vn_peek_array_size(dec)) {
3618 const size_t array_size = vn_decode_array_size(dec, args->dataSize);
3619 args->pData = vn_cs_decoder_alloc_temp(dec, array_size);
3620 if (!args->pData) return;
3621 vn_decode_blob_array(dec, (void *)args->pData, array_size);
3622 } else {
3623 vn_decode_array_size(dec, args->dataSize);
3624 args->pData = NULL;
3625 }
3626 }
3627
vn_replace_vkCmdUpdateBuffer_args_handle(struct vn_command_vkCmdUpdateBuffer * args)3628 static inline void vn_replace_vkCmdUpdateBuffer_args_handle(struct vn_command_vkCmdUpdateBuffer *args)
3629 {
3630 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3631 vn_replace_VkBuffer_handle(&args->dstBuffer);
3632 /* skip args->dstOffset */
3633 /* skip args->dataSize */
3634 /* skip args->pData */
3635 }
3636
vn_encode_vkCmdUpdateBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdUpdateBuffer * args)3637 static inline void vn_encode_vkCmdUpdateBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdUpdateBuffer *args)
3638 {
3639 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdUpdateBuffer_EXT});
3640
3641 /* skip args->commandBuffer */
3642 /* skip args->dstBuffer */
3643 /* skip args->dstOffset */
3644 /* skip args->dataSize */
3645 /* skip args->pData */
3646 }
3647
vn_decode_vkCmdFillBuffer_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdFillBuffer * args)3648 static inline void vn_decode_vkCmdFillBuffer_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdFillBuffer *args)
3649 {
3650 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3651 vn_decode_VkBuffer_lookup(dec, &args->dstBuffer);
3652 vn_decode_VkDeviceSize(dec, &args->dstOffset);
3653 vn_decode_VkDeviceSize(dec, &args->size);
3654 vn_decode_uint32_t(dec, &args->data);
3655 }
3656
vn_replace_vkCmdFillBuffer_args_handle(struct vn_command_vkCmdFillBuffer * args)3657 static inline void vn_replace_vkCmdFillBuffer_args_handle(struct vn_command_vkCmdFillBuffer *args)
3658 {
3659 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3660 vn_replace_VkBuffer_handle(&args->dstBuffer);
3661 /* skip args->dstOffset */
3662 /* skip args->size */
3663 /* skip args->data */
3664 }
3665
vn_encode_vkCmdFillBuffer_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdFillBuffer * args)3666 static inline void vn_encode_vkCmdFillBuffer_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdFillBuffer *args)
3667 {
3668 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdFillBuffer_EXT});
3669
3670 /* skip args->commandBuffer */
3671 /* skip args->dstBuffer */
3672 /* skip args->dstOffset */
3673 /* skip args->size */
3674 /* skip args->data */
3675 }
3676
vn_decode_vkCmdClearColorImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdClearColorImage * args)3677 static inline void vn_decode_vkCmdClearColorImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdClearColorImage *args)
3678 {
3679 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3680 vn_decode_VkImage_lookup(dec, &args->image);
3681 vn_decode_VkImageLayout(dec, &args->imageLayout);
3682 if (vn_decode_simple_pointer(dec)) {
3683 args->pColor = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pColor));
3684 if (!args->pColor) return;
3685 vn_decode_VkClearColorValue_temp(dec, (VkClearColorValue *)args->pColor);
3686 } else {
3687 args->pColor = NULL;
3688 }
3689 vn_decode_uint32_t(dec, &args->rangeCount);
3690 if (vn_peek_array_size(dec)) {
3691 const uint32_t iter_count = vn_decode_array_size(dec, args->rangeCount);
3692 args->pRanges = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRanges) * iter_count);
3693 if (!args->pRanges) return;
3694 for (uint32_t i = 0; i < iter_count; i++)
3695 vn_decode_VkImageSubresourceRange_temp(dec, &((VkImageSubresourceRange *)args->pRanges)[i]);
3696 } else {
3697 vn_decode_array_size(dec, args->rangeCount);
3698 args->pRanges = NULL;
3699 }
3700 }
3701
vn_replace_vkCmdClearColorImage_args_handle(struct vn_command_vkCmdClearColorImage * args)3702 static inline void vn_replace_vkCmdClearColorImage_args_handle(struct vn_command_vkCmdClearColorImage *args)
3703 {
3704 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3705 vn_replace_VkImage_handle(&args->image);
3706 /* skip args->imageLayout */
3707 /* skip args->pColor */
3708 /* skip args->rangeCount */
3709 if (args->pRanges) {
3710 for (uint32_t i = 0; i < args->rangeCount; i++)
3711 vn_replace_VkImageSubresourceRange_handle(&((VkImageSubresourceRange *)args->pRanges)[i]);
3712 }
3713 }
3714
vn_encode_vkCmdClearColorImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdClearColorImage * args)3715 static inline void vn_encode_vkCmdClearColorImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdClearColorImage *args)
3716 {
3717 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdClearColorImage_EXT});
3718
3719 /* skip args->commandBuffer */
3720 /* skip args->image */
3721 /* skip args->imageLayout */
3722 /* skip args->pColor */
3723 /* skip args->rangeCount */
3724 /* skip args->pRanges */
3725 }
3726
vn_decode_vkCmdClearDepthStencilImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdClearDepthStencilImage * args)3727 static inline void vn_decode_vkCmdClearDepthStencilImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdClearDepthStencilImage *args)
3728 {
3729 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3730 vn_decode_VkImage_lookup(dec, &args->image);
3731 vn_decode_VkImageLayout(dec, &args->imageLayout);
3732 if (vn_decode_simple_pointer(dec)) {
3733 args->pDepthStencil = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDepthStencil));
3734 if (!args->pDepthStencil) return;
3735 vn_decode_VkClearDepthStencilValue_temp(dec, (VkClearDepthStencilValue *)args->pDepthStencil);
3736 } else {
3737 args->pDepthStencil = NULL;
3738 vn_cs_decoder_set_fatal(dec);
3739 }
3740 vn_decode_uint32_t(dec, &args->rangeCount);
3741 if (vn_peek_array_size(dec)) {
3742 const uint32_t iter_count = vn_decode_array_size(dec, args->rangeCount);
3743 args->pRanges = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRanges) * iter_count);
3744 if (!args->pRanges) return;
3745 for (uint32_t i = 0; i < iter_count; i++)
3746 vn_decode_VkImageSubresourceRange_temp(dec, &((VkImageSubresourceRange *)args->pRanges)[i]);
3747 } else {
3748 vn_decode_array_size(dec, args->rangeCount);
3749 args->pRanges = NULL;
3750 }
3751 }
3752
vn_replace_vkCmdClearDepthStencilImage_args_handle(struct vn_command_vkCmdClearDepthStencilImage * args)3753 static inline void vn_replace_vkCmdClearDepthStencilImage_args_handle(struct vn_command_vkCmdClearDepthStencilImage *args)
3754 {
3755 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3756 vn_replace_VkImage_handle(&args->image);
3757 /* skip args->imageLayout */
3758 if (args->pDepthStencil)
3759 vn_replace_VkClearDepthStencilValue_handle((VkClearDepthStencilValue *)args->pDepthStencil);
3760 /* skip args->rangeCount */
3761 if (args->pRanges) {
3762 for (uint32_t i = 0; i < args->rangeCount; i++)
3763 vn_replace_VkImageSubresourceRange_handle(&((VkImageSubresourceRange *)args->pRanges)[i]);
3764 }
3765 }
3766
vn_encode_vkCmdClearDepthStencilImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdClearDepthStencilImage * args)3767 static inline void vn_encode_vkCmdClearDepthStencilImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdClearDepthStencilImage *args)
3768 {
3769 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdClearDepthStencilImage_EXT});
3770
3771 /* skip args->commandBuffer */
3772 /* skip args->image */
3773 /* skip args->imageLayout */
3774 /* skip args->pDepthStencil */
3775 /* skip args->rangeCount */
3776 /* skip args->pRanges */
3777 }
3778
vn_decode_vkCmdClearAttachments_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdClearAttachments * args)3779 static inline void vn_decode_vkCmdClearAttachments_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdClearAttachments *args)
3780 {
3781 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3782 vn_decode_uint32_t(dec, &args->attachmentCount);
3783 if (vn_peek_array_size(dec)) {
3784 const uint32_t iter_count = vn_decode_array_size(dec, args->attachmentCount);
3785 args->pAttachments = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pAttachments) * iter_count);
3786 if (!args->pAttachments) return;
3787 for (uint32_t i = 0; i < iter_count; i++)
3788 vn_decode_VkClearAttachment_temp(dec, &((VkClearAttachment *)args->pAttachments)[i]);
3789 } else {
3790 vn_decode_array_size(dec, args->attachmentCount);
3791 args->pAttachments = NULL;
3792 }
3793 vn_decode_uint32_t(dec, &args->rectCount);
3794 if (vn_peek_array_size(dec)) {
3795 const uint32_t iter_count = vn_decode_array_size(dec, args->rectCount);
3796 args->pRects = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRects) * iter_count);
3797 if (!args->pRects) return;
3798 for (uint32_t i = 0; i < iter_count; i++)
3799 vn_decode_VkClearRect_temp(dec, &((VkClearRect *)args->pRects)[i]);
3800 } else {
3801 vn_decode_array_size(dec, args->rectCount);
3802 args->pRects = NULL;
3803 }
3804 }
3805
vn_replace_vkCmdClearAttachments_args_handle(struct vn_command_vkCmdClearAttachments * args)3806 static inline void vn_replace_vkCmdClearAttachments_args_handle(struct vn_command_vkCmdClearAttachments *args)
3807 {
3808 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3809 /* skip args->attachmentCount */
3810 if (args->pAttachments) {
3811 for (uint32_t i = 0; i < args->attachmentCount; i++)
3812 vn_replace_VkClearAttachment_handle(&((VkClearAttachment *)args->pAttachments)[i]);
3813 }
3814 /* skip args->rectCount */
3815 if (args->pRects) {
3816 for (uint32_t i = 0; i < args->rectCount; i++)
3817 vn_replace_VkClearRect_handle(&((VkClearRect *)args->pRects)[i]);
3818 }
3819 }
3820
vn_encode_vkCmdClearAttachments_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdClearAttachments * args)3821 static inline void vn_encode_vkCmdClearAttachments_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdClearAttachments *args)
3822 {
3823 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdClearAttachments_EXT});
3824
3825 /* skip args->commandBuffer */
3826 /* skip args->attachmentCount */
3827 /* skip args->pAttachments */
3828 /* skip args->rectCount */
3829 /* skip args->pRects */
3830 }
3831
vn_decode_vkCmdResolveImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdResolveImage * args)3832 static inline void vn_decode_vkCmdResolveImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResolveImage *args)
3833 {
3834 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3835 vn_decode_VkImage_lookup(dec, &args->srcImage);
3836 vn_decode_VkImageLayout(dec, &args->srcImageLayout);
3837 vn_decode_VkImage_lookup(dec, &args->dstImage);
3838 vn_decode_VkImageLayout(dec, &args->dstImageLayout);
3839 vn_decode_uint32_t(dec, &args->regionCount);
3840 if (vn_peek_array_size(dec)) {
3841 const uint32_t iter_count = vn_decode_array_size(dec, args->regionCount);
3842 args->pRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRegions) * iter_count);
3843 if (!args->pRegions) return;
3844 for (uint32_t i = 0; i < iter_count; i++)
3845 vn_decode_VkImageResolve_temp(dec, &((VkImageResolve *)args->pRegions)[i]);
3846 } else {
3847 vn_decode_array_size(dec, args->regionCount);
3848 args->pRegions = NULL;
3849 }
3850 }
3851
vn_replace_vkCmdResolveImage_args_handle(struct vn_command_vkCmdResolveImage * args)3852 static inline void vn_replace_vkCmdResolveImage_args_handle(struct vn_command_vkCmdResolveImage *args)
3853 {
3854 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3855 vn_replace_VkImage_handle(&args->srcImage);
3856 /* skip args->srcImageLayout */
3857 vn_replace_VkImage_handle(&args->dstImage);
3858 /* skip args->dstImageLayout */
3859 /* skip args->regionCount */
3860 if (args->pRegions) {
3861 for (uint32_t i = 0; i < args->regionCount; i++)
3862 vn_replace_VkImageResolve_handle(&((VkImageResolve *)args->pRegions)[i]);
3863 }
3864 }
3865
vn_encode_vkCmdResolveImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdResolveImage * args)3866 static inline void vn_encode_vkCmdResolveImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResolveImage *args)
3867 {
3868 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResolveImage_EXT});
3869
3870 /* skip args->commandBuffer */
3871 /* skip args->srcImage */
3872 /* skip args->srcImageLayout */
3873 /* skip args->dstImage */
3874 /* skip args->dstImageLayout */
3875 /* skip args->regionCount */
3876 /* skip args->pRegions */
3877 }
3878
vn_decode_vkCmdSetEvent_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetEvent * args)3879 static inline void vn_decode_vkCmdSetEvent_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetEvent *args)
3880 {
3881 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3882 vn_decode_VkEvent_lookup(dec, &args->event);
3883 vn_decode_VkFlags(dec, &args->stageMask);
3884 }
3885
vn_replace_vkCmdSetEvent_args_handle(struct vn_command_vkCmdSetEvent * args)3886 static inline void vn_replace_vkCmdSetEvent_args_handle(struct vn_command_vkCmdSetEvent *args)
3887 {
3888 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3889 vn_replace_VkEvent_handle(&args->event);
3890 /* skip args->stageMask */
3891 }
3892
vn_encode_vkCmdSetEvent_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetEvent * args)3893 static inline void vn_encode_vkCmdSetEvent_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetEvent *args)
3894 {
3895 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetEvent_EXT});
3896
3897 /* skip args->commandBuffer */
3898 /* skip args->event */
3899 /* skip args->stageMask */
3900 }
3901
vn_decode_vkCmdResetEvent_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdResetEvent * args)3902 static inline void vn_decode_vkCmdResetEvent_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResetEvent *args)
3903 {
3904 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3905 vn_decode_VkEvent_lookup(dec, &args->event);
3906 vn_decode_VkFlags(dec, &args->stageMask);
3907 }
3908
vn_replace_vkCmdResetEvent_args_handle(struct vn_command_vkCmdResetEvent * args)3909 static inline void vn_replace_vkCmdResetEvent_args_handle(struct vn_command_vkCmdResetEvent *args)
3910 {
3911 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3912 vn_replace_VkEvent_handle(&args->event);
3913 /* skip args->stageMask */
3914 }
3915
vn_encode_vkCmdResetEvent_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdResetEvent * args)3916 static inline void vn_encode_vkCmdResetEvent_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResetEvent *args)
3917 {
3918 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResetEvent_EXT});
3919
3920 /* skip args->commandBuffer */
3921 /* skip args->event */
3922 /* skip args->stageMask */
3923 }
3924
vn_decode_vkCmdWaitEvents_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdWaitEvents * args)3925 static inline void vn_decode_vkCmdWaitEvents_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdWaitEvents *args)
3926 {
3927 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
3928 vn_decode_uint32_t(dec, &args->eventCount);
3929 if (vn_peek_array_size(dec)) {
3930 const uint32_t iter_count = vn_decode_array_size(dec, args->eventCount);
3931 args->pEvents = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pEvents) * iter_count);
3932 if (!args->pEvents) return;
3933 for (uint32_t i = 0; i < iter_count; i++)
3934 vn_decode_VkEvent_lookup(dec, &((VkEvent *)args->pEvents)[i]);
3935 } else {
3936 vn_decode_array_size(dec, args->eventCount);
3937 args->pEvents = NULL;
3938 }
3939 vn_decode_VkFlags(dec, &args->srcStageMask);
3940 vn_decode_VkFlags(dec, &args->dstStageMask);
3941 vn_decode_uint32_t(dec, &args->memoryBarrierCount);
3942 if (vn_peek_array_size(dec)) {
3943 const uint32_t iter_count = vn_decode_array_size(dec, args->memoryBarrierCount);
3944 args->pMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryBarriers) * iter_count);
3945 if (!args->pMemoryBarriers) return;
3946 for (uint32_t i = 0; i < iter_count; i++)
3947 vn_decode_VkMemoryBarrier_temp(dec, &((VkMemoryBarrier *)args->pMemoryBarriers)[i]);
3948 } else {
3949 vn_decode_array_size(dec, args->memoryBarrierCount);
3950 args->pMemoryBarriers = NULL;
3951 }
3952 vn_decode_uint32_t(dec, &args->bufferMemoryBarrierCount);
3953 if (vn_peek_array_size(dec)) {
3954 const uint32_t iter_count = vn_decode_array_size(dec, args->bufferMemoryBarrierCount);
3955 args->pBufferMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBufferMemoryBarriers) * iter_count);
3956 if (!args->pBufferMemoryBarriers) return;
3957 for (uint32_t i = 0; i < iter_count; i++)
3958 vn_decode_VkBufferMemoryBarrier_temp(dec, &((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]);
3959 } else {
3960 vn_decode_array_size(dec, args->bufferMemoryBarrierCount);
3961 args->pBufferMemoryBarriers = NULL;
3962 }
3963 vn_decode_uint32_t(dec, &args->imageMemoryBarrierCount);
3964 if (vn_peek_array_size(dec)) {
3965 const uint32_t iter_count = vn_decode_array_size(dec, args->imageMemoryBarrierCount);
3966 args->pImageMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImageMemoryBarriers) * iter_count);
3967 if (!args->pImageMemoryBarriers) return;
3968 for (uint32_t i = 0; i < iter_count; i++)
3969 vn_decode_VkImageMemoryBarrier_temp(dec, &((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]);
3970 } else {
3971 vn_decode_array_size(dec, args->imageMemoryBarrierCount);
3972 args->pImageMemoryBarriers = NULL;
3973 }
3974 }
3975
vn_replace_vkCmdWaitEvents_args_handle(struct vn_command_vkCmdWaitEvents * args)3976 static inline void vn_replace_vkCmdWaitEvents_args_handle(struct vn_command_vkCmdWaitEvents *args)
3977 {
3978 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
3979 /* skip args->eventCount */
3980 if (args->pEvents) {
3981 for (uint32_t i = 0; i < args->eventCount; i++)
3982 vn_replace_VkEvent_handle(&((VkEvent *)args->pEvents)[i]);
3983 }
3984 /* skip args->srcStageMask */
3985 /* skip args->dstStageMask */
3986 /* skip args->memoryBarrierCount */
3987 if (args->pMemoryBarriers) {
3988 for (uint32_t i = 0; i < args->memoryBarrierCount; i++)
3989 vn_replace_VkMemoryBarrier_handle(&((VkMemoryBarrier *)args->pMemoryBarriers)[i]);
3990 }
3991 /* skip args->bufferMemoryBarrierCount */
3992 if (args->pBufferMemoryBarriers) {
3993 for (uint32_t i = 0; i < args->bufferMemoryBarrierCount; i++)
3994 vn_replace_VkBufferMemoryBarrier_handle(&((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]);
3995 }
3996 /* skip args->imageMemoryBarrierCount */
3997 if (args->pImageMemoryBarriers) {
3998 for (uint32_t i = 0; i < args->imageMemoryBarrierCount; i++)
3999 vn_replace_VkImageMemoryBarrier_handle(&((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]);
4000 }
4001 }
4002
vn_encode_vkCmdWaitEvents_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdWaitEvents * args)4003 static inline void vn_encode_vkCmdWaitEvents_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdWaitEvents *args)
4004 {
4005 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdWaitEvents_EXT});
4006
4007 /* skip args->commandBuffer */
4008 /* skip args->eventCount */
4009 /* skip args->pEvents */
4010 /* skip args->srcStageMask */
4011 /* skip args->dstStageMask */
4012 /* skip args->memoryBarrierCount */
4013 /* skip args->pMemoryBarriers */
4014 /* skip args->bufferMemoryBarrierCount */
4015 /* skip args->pBufferMemoryBarriers */
4016 /* skip args->imageMemoryBarrierCount */
4017 /* skip args->pImageMemoryBarriers */
4018 }
4019
vn_decode_vkCmdPipelineBarrier_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdPipelineBarrier * args)4020 static inline void vn_decode_vkCmdPipelineBarrier_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdPipelineBarrier *args)
4021 {
4022 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4023 vn_decode_VkFlags(dec, &args->srcStageMask);
4024 vn_decode_VkFlags(dec, &args->dstStageMask);
4025 vn_decode_VkFlags(dec, &args->dependencyFlags);
4026 vn_decode_uint32_t(dec, &args->memoryBarrierCount);
4027 if (vn_peek_array_size(dec)) {
4028 const uint32_t iter_count = vn_decode_array_size(dec, args->memoryBarrierCount);
4029 args->pMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryBarriers) * iter_count);
4030 if (!args->pMemoryBarriers) return;
4031 for (uint32_t i = 0; i < iter_count; i++)
4032 vn_decode_VkMemoryBarrier_temp(dec, &((VkMemoryBarrier *)args->pMemoryBarriers)[i]);
4033 } else {
4034 vn_decode_array_size(dec, args->memoryBarrierCount);
4035 args->pMemoryBarriers = NULL;
4036 }
4037 vn_decode_uint32_t(dec, &args->bufferMemoryBarrierCount);
4038 if (vn_peek_array_size(dec)) {
4039 const uint32_t iter_count = vn_decode_array_size(dec, args->bufferMemoryBarrierCount);
4040 args->pBufferMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBufferMemoryBarriers) * iter_count);
4041 if (!args->pBufferMemoryBarriers) return;
4042 for (uint32_t i = 0; i < iter_count; i++)
4043 vn_decode_VkBufferMemoryBarrier_temp(dec, &((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]);
4044 } else {
4045 vn_decode_array_size(dec, args->bufferMemoryBarrierCount);
4046 args->pBufferMemoryBarriers = NULL;
4047 }
4048 vn_decode_uint32_t(dec, &args->imageMemoryBarrierCount);
4049 if (vn_peek_array_size(dec)) {
4050 const uint32_t iter_count = vn_decode_array_size(dec, args->imageMemoryBarrierCount);
4051 args->pImageMemoryBarriers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImageMemoryBarriers) * iter_count);
4052 if (!args->pImageMemoryBarriers) return;
4053 for (uint32_t i = 0; i < iter_count; i++)
4054 vn_decode_VkImageMemoryBarrier_temp(dec, &((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]);
4055 } else {
4056 vn_decode_array_size(dec, args->imageMemoryBarrierCount);
4057 args->pImageMemoryBarriers = NULL;
4058 }
4059 }
4060
vn_replace_vkCmdPipelineBarrier_args_handle(struct vn_command_vkCmdPipelineBarrier * args)4061 static inline void vn_replace_vkCmdPipelineBarrier_args_handle(struct vn_command_vkCmdPipelineBarrier *args)
4062 {
4063 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4064 /* skip args->srcStageMask */
4065 /* skip args->dstStageMask */
4066 /* skip args->dependencyFlags */
4067 /* skip args->memoryBarrierCount */
4068 if (args->pMemoryBarriers) {
4069 for (uint32_t i = 0; i < args->memoryBarrierCount; i++)
4070 vn_replace_VkMemoryBarrier_handle(&((VkMemoryBarrier *)args->pMemoryBarriers)[i]);
4071 }
4072 /* skip args->bufferMemoryBarrierCount */
4073 if (args->pBufferMemoryBarriers) {
4074 for (uint32_t i = 0; i < args->bufferMemoryBarrierCount; i++)
4075 vn_replace_VkBufferMemoryBarrier_handle(&((VkBufferMemoryBarrier *)args->pBufferMemoryBarriers)[i]);
4076 }
4077 /* skip args->imageMemoryBarrierCount */
4078 if (args->pImageMemoryBarriers) {
4079 for (uint32_t i = 0; i < args->imageMemoryBarrierCount; i++)
4080 vn_replace_VkImageMemoryBarrier_handle(&((VkImageMemoryBarrier *)args->pImageMemoryBarriers)[i]);
4081 }
4082 }
4083
vn_encode_vkCmdPipelineBarrier_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdPipelineBarrier * args)4084 static inline void vn_encode_vkCmdPipelineBarrier_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdPipelineBarrier *args)
4085 {
4086 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdPipelineBarrier_EXT});
4087
4088 /* skip args->commandBuffer */
4089 /* skip args->srcStageMask */
4090 /* skip args->dstStageMask */
4091 /* skip args->dependencyFlags */
4092 /* skip args->memoryBarrierCount */
4093 /* skip args->pMemoryBarriers */
4094 /* skip args->bufferMemoryBarrierCount */
4095 /* skip args->pBufferMemoryBarriers */
4096 /* skip args->imageMemoryBarrierCount */
4097 /* skip args->pImageMemoryBarriers */
4098 }
4099
vn_decode_vkCmdBeginQuery_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBeginQuery * args)4100 static inline void vn_decode_vkCmdBeginQuery_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginQuery *args)
4101 {
4102 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4103 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
4104 vn_decode_uint32_t(dec, &args->query);
4105 vn_decode_VkFlags(dec, &args->flags);
4106 }
4107
vn_replace_vkCmdBeginQuery_args_handle(struct vn_command_vkCmdBeginQuery * args)4108 static inline void vn_replace_vkCmdBeginQuery_args_handle(struct vn_command_vkCmdBeginQuery *args)
4109 {
4110 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4111 vn_replace_VkQueryPool_handle(&args->queryPool);
4112 /* skip args->query */
4113 /* skip args->flags */
4114 }
4115
vn_encode_vkCmdBeginQuery_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBeginQuery * args)4116 static inline void vn_encode_vkCmdBeginQuery_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginQuery *args)
4117 {
4118 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginQuery_EXT});
4119
4120 /* skip args->commandBuffer */
4121 /* skip args->queryPool */
4122 /* skip args->query */
4123 /* skip args->flags */
4124 }
4125
vn_decode_vkCmdEndQuery_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdEndQuery * args)4126 static inline void vn_decode_vkCmdEndQuery_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndQuery *args)
4127 {
4128 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4129 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
4130 vn_decode_uint32_t(dec, &args->query);
4131 }
4132
vn_replace_vkCmdEndQuery_args_handle(struct vn_command_vkCmdEndQuery * args)4133 static inline void vn_replace_vkCmdEndQuery_args_handle(struct vn_command_vkCmdEndQuery *args)
4134 {
4135 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4136 vn_replace_VkQueryPool_handle(&args->queryPool);
4137 /* skip args->query */
4138 }
4139
vn_encode_vkCmdEndQuery_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdEndQuery * args)4140 static inline void vn_encode_vkCmdEndQuery_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndQuery *args)
4141 {
4142 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndQuery_EXT});
4143
4144 /* skip args->commandBuffer */
4145 /* skip args->queryPool */
4146 /* skip args->query */
4147 }
4148
vn_decode_vkCmdBeginConditionalRenderingEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBeginConditionalRenderingEXT * args)4149 static inline void vn_decode_vkCmdBeginConditionalRenderingEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginConditionalRenderingEXT *args)
4150 {
4151 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4152 if (vn_decode_simple_pointer(dec)) {
4153 args->pConditionalRenderingBegin = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pConditionalRenderingBegin));
4154 if (!args->pConditionalRenderingBegin) return;
4155 vn_decode_VkConditionalRenderingBeginInfoEXT_temp(dec, (VkConditionalRenderingBeginInfoEXT *)args->pConditionalRenderingBegin);
4156 } else {
4157 args->pConditionalRenderingBegin = NULL;
4158 vn_cs_decoder_set_fatal(dec);
4159 }
4160 }
4161
vn_replace_vkCmdBeginConditionalRenderingEXT_args_handle(struct vn_command_vkCmdBeginConditionalRenderingEXT * args)4162 static inline void vn_replace_vkCmdBeginConditionalRenderingEXT_args_handle(struct vn_command_vkCmdBeginConditionalRenderingEXT *args)
4163 {
4164 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4165 if (args->pConditionalRenderingBegin)
4166 vn_replace_VkConditionalRenderingBeginInfoEXT_handle((VkConditionalRenderingBeginInfoEXT *)args->pConditionalRenderingBegin);
4167 }
4168
vn_encode_vkCmdBeginConditionalRenderingEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBeginConditionalRenderingEXT * args)4169 static inline void vn_encode_vkCmdBeginConditionalRenderingEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginConditionalRenderingEXT *args)
4170 {
4171 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginConditionalRenderingEXT_EXT});
4172
4173 /* skip args->commandBuffer */
4174 /* skip args->pConditionalRenderingBegin */
4175 }
4176
vn_decode_vkCmdEndConditionalRenderingEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdEndConditionalRenderingEXT * args)4177 static inline void vn_decode_vkCmdEndConditionalRenderingEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndConditionalRenderingEXT *args)
4178 {
4179 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4180 }
4181
vn_replace_vkCmdEndConditionalRenderingEXT_args_handle(struct vn_command_vkCmdEndConditionalRenderingEXT * args)4182 static inline void vn_replace_vkCmdEndConditionalRenderingEXT_args_handle(struct vn_command_vkCmdEndConditionalRenderingEXT *args)
4183 {
4184 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4185 }
4186
vn_encode_vkCmdEndConditionalRenderingEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdEndConditionalRenderingEXT * args)4187 static inline void vn_encode_vkCmdEndConditionalRenderingEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndConditionalRenderingEXT *args)
4188 {
4189 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndConditionalRenderingEXT_EXT});
4190
4191 /* skip args->commandBuffer */
4192 }
4193
vn_decode_vkCmdResetQueryPool_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdResetQueryPool * args)4194 static inline void vn_decode_vkCmdResetQueryPool_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResetQueryPool *args)
4195 {
4196 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4197 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
4198 vn_decode_uint32_t(dec, &args->firstQuery);
4199 vn_decode_uint32_t(dec, &args->queryCount);
4200 }
4201
vn_replace_vkCmdResetQueryPool_args_handle(struct vn_command_vkCmdResetQueryPool * args)4202 static inline void vn_replace_vkCmdResetQueryPool_args_handle(struct vn_command_vkCmdResetQueryPool *args)
4203 {
4204 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4205 vn_replace_VkQueryPool_handle(&args->queryPool);
4206 /* skip args->firstQuery */
4207 /* skip args->queryCount */
4208 }
4209
vn_encode_vkCmdResetQueryPool_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdResetQueryPool * args)4210 static inline void vn_encode_vkCmdResetQueryPool_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResetQueryPool *args)
4211 {
4212 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResetQueryPool_EXT});
4213
4214 /* skip args->commandBuffer */
4215 /* skip args->queryPool */
4216 /* skip args->firstQuery */
4217 /* skip args->queryCount */
4218 }
4219
vn_decode_vkCmdWriteTimestamp_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdWriteTimestamp * args)4220 static inline void vn_decode_vkCmdWriteTimestamp_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdWriteTimestamp *args)
4221 {
4222 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4223 vn_decode_VkPipelineStageFlagBits(dec, &args->pipelineStage);
4224 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
4225 vn_decode_uint32_t(dec, &args->query);
4226 }
4227
vn_replace_vkCmdWriteTimestamp_args_handle(struct vn_command_vkCmdWriteTimestamp * args)4228 static inline void vn_replace_vkCmdWriteTimestamp_args_handle(struct vn_command_vkCmdWriteTimestamp *args)
4229 {
4230 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4231 /* skip args->pipelineStage */
4232 vn_replace_VkQueryPool_handle(&args->queryPool);
4233 /* skip args->query */
4234 }
4235
vn_encode_vkCmdWriteTimestamp_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdWriteTimestamp * args)4236 static inline void vn_encode_vkCmdWriteTimestamp_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdWriteTimestamp *args)
4237 {
4238 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdWriteTimestamp_EXT});
4239
4240 /* skip args->commandBuffer */
4241 /* skip args->pipelineStage */
4242 /* skip args->queryPool */
4243 /* skip args->query */
4244 }
4245
vn_decode_vkCmdCopyQueryPoolResults_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyQueryPoolResults * args)4246 static inline void vn_decode_vkCmdCopyQueryPoolResults_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyQueryPoolResults *args)
4247 {
4248 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4249 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
4250 vn_decode_uint32_t(dec, &args->firstQuery);
4251 vn_decode_uint32_t(dec, &args->queryCount);
4252 vn_decode_VkBuffer_lookup(dec, &args->dstBuffer);
4253 vn_decode_VkDeviceSize(dec, &args->dstOffset);
4254 vn_decode_VkDeviceSize(dec, &args->stride);
4255 vn_decode_VkFlags(dec, &args->flags);
4256 }
4257
vn_replace_vkCmdCopyQueryPoolResults_args_handle(struct vn_command_vkCmdCopyQueryPoolResults * args)4258 static inline void vn_replace_vkCmdCopyQueryPoolResults_args_handle(struct vn_command_vkCmdCopyQueryPoolResults *args)
4259 {
4260 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4261 vn_replace_VkQueryPool_handle(&args->queryPool);
4262 /* skip args->firstQuery */
4263 /* skip args->queryCount */
4264 vn_replace_VkBuffer_handle(&args->dstBuffer);
4265 /* skip args->dstOffset */
4266 /* skip args->stride */
4267 /* skip args->flags */
4268 }
4269
vn_encode_vkCmdCopyQueryPoolResults_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyQueryPoolResults * args)4270 static inline void vn_encode_vkCmdCopyQueryPoolResults_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyQueryPoolResults *args)
4271 {
4272 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyQueryPoolResults_EXT});
4273
4274 /* skip args->commandBuffer */
4275 /* skip args->queryPool */
4276 /* skip args->firstQuery */
4277 /* skip args->queryCount */
4278 /* skip args->dstBuffer */
4279 /* skip args->dstOffset */
4280 /* skip args->stride */
4281 /* skip args->flags */
4282 }
4283
vn_decode_vkCmdPushConstants_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdPushConstants * args)4284 static inline void vn_decode_vkCmdPushConstants_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdPushConstants *args)
4285 {
4286 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4287 vn_decode_VkPipelineLayout_lookup(dec, &args->layout);
4288 vn_decode_VkFlags(dec, &args->stageFlags);
4289 vn_decode_uint32_t(dec, &args->offset);
4290 vn_decode_uint32_t(dec, &args->size);
4291 if (vn_peek_array_size(dec)) {
4292 const size_t array_size = vn_decode_array_size(dec, args->size);
4293 args->pValues = vn_cs_decoder_alloc_temp(dec, array_size);
4294 if (!args->pValues) return;
4295 vn_decode_blob_array(dec, (void *)args->pValues, array_size);
4296 } else {
4297 vn_decode_array_size(dec, args->size);
4298 args->pValues = NULL;
4299 }
4300 }
4301
vn_replace_vkCmdPushConstants_args_handle(struct vn_command_vkCmdPushConstants * args)4302 static inline void vn_replace_vkCmdPushConstants_args_handle(struct vn_command_vkCmdPushConstants *args)
4303 {
4304 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4305 vn_replace_VkPipelineLayout_handle(&args->layout);
4306 /* skip args->stageFlags */
4307 /* skip args->offset */
4308 /* skip args->size */
4309 /* skip args->pValues */
4310 }
4311
vn_encode_vkCmdPushConstants_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdPushConstants * args)4312 static inline void vn_encode_vkCmdPushConstants_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdPushConstants *args)
4313 {
4314 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdPushConstants_EXT});
4315
4316 /* skip args->commandBuffer */
4317 /* skip args->layout */
4318 /* skip args->stageFlags */
4319 /* skip args->offset */
4320 /* skip args->size */
4321 /* skip args->pValues */
4322 }
4323
vn_decode_vkCmdBeginRenderPass_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBeginRenderPass * args)4324 static inline void vn_decode_vkCmdBeginRenderPass_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginRenderPass *args)
4325 {
4326 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4327 if (vn_decode_simple_pointer(dec)) {
4328 args->pRenderPassBegin = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRenderPassBegin));
4329 if (!args->pRenderPassBegin) return;
4330 vn_decode_VkRenderPassBeginInfo_temp(dec, (VkRenderPassBeginInfo *)args->pRenderPassBegin);
4331 } else {
4332 args->pRenderPassBegin = NULL;
4333 vn_cs_decoder_set_fatal(dec);
4334 }
4335 vn_decode_VkSubpassContents(dec, &args->contents);
4336 }
4337
vn_replace_vkCmdBeginRenderPass_args_handle(struct vn_command_vkCmdBeginRenderPass * args)4338 static inline void vn_replace_vkCmdBeginRenderPass_args_handle(struct vn_command_vkCmdBeginRenderPass *args)
4339 {
4340 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4341 if (args->pRenderPassBegin)
4342 vn_replace_VkRenderPassBeginInfo_handle((VkRenderPassBeginInfo *)args->pRenderPassBegin);
4343 /* skip args->contents */
4344 }
4345
vn_encode_vkCmdBeginRenderPass_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBeginRenderPass * args)4346 static inline void vn_encode_vkCmdBeginRenderPass_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginRenderPass *args)
4347 {
4348 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginRenderPass_EXT});
4349
4350 /* skip args->commandBuffer */
4351 /* skip args->pRenderPassBegin */
4352 /* skip args->contents */
4353 }
4354
vn_decode_vkCmdNextSubpass_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdNextSubpass * args)4355 static inline void vn_decode_vkCmdNextSubpass_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdNextSubpass *args)
4356 {
4357 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4358 vn_decode_VkSubpassContents(dec, &args->contents);
4359 }
4360
vn_replace_vkCmdNextSubpass_args_handle(struct vn_command_vkCmdNextSubpass * args)4361 static inline void vn_replace_vkCmdNextSubpass_args_handle(struct vn_command_vkCmdNextSubpass *args)
4362 {
4363 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4364 /* skip args->contents */
4365 }
4366
vn_encode_vkCmdNextSubpass_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdNextSubpass * args)4367 static inline void vn_encode_vkCmdNextSubpass_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdNextSubpass *args)
4368 {
4369 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdNextSubpass_EXT});
4370
4371 /* skip args->commandBuffer */
4372 /* skip args->contents */
4373 }
4374
vn_decode_vkCmdEndRenderPass_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdEndRenderPass * args)4375 static inline void vn_decode_vkCmdEndRenderPass_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndRenderPass *args)
4376 {
4377 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4378 }
4379
vn_replace_vkCmdEndRenderPass_args_handle(struct vn_command_vkCmdEndRenderPass * args)4380 static inline void vn_replace_vkCmdEndRenderPass_args_handle(struct vn_command_vkCmdEndRenderPass *args)
4381 {
4382 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4383 }
4384
vn_encode_vkCmdEndRenderPass_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdEndRenderPass * args)4385 static inline void vn_encode_vkCmdEndRenderPass_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndRenderPass *args)
4386 {
4387 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndRenderPass_EXT});
4388
4389 /* skip args->commandBuffer */
4390 }
4391
vn_decode_vkCmdExecuteCommands_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdExecuteCommands * args)4392 static inline void vn_decode_vkCmdExecuteCommands_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdExecuteCommands *args)
4393 {
4394 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4395 vn_decode_uint32_t(dec, &args->commandBufferCount);
4396 if (vn_peek_array_size(dec)) {
4397 const uint32_t iter_count = vn_decode_array_size(dec, args->commandBufferCount);
4398 args->pCommandBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCommandBuffers) * iter_count);
4399 if (!args->pCommandBuffers) return;
4400 for (uint32_t i = 0; i < iter_count; i++)
4401 vn_decode_VkCommandBuffer_lookup(dec, &((VkCommandBuffer *)args->pCommandBuffers)[i]);
4402 } else {
4403 vn_decode_array_size(dec, args->commandBufferCount);
4404 args->pCommandBuffers = NULL;
4405 }
4406 }
4407
vn_replace_vkCmdExecuteCommands_args_handle(struct vn_command_vkCmdExecuteCommands * args)4408 static inline void vn_replace_vkCmdExecuteCommands_args_handle(struct vn_command_vkCmdExecuteCommands *args)
4409 {
4410 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4411 /* skip args->commandBufferCount */
4412 if (args->pCommandBuffers) {
4413 for (uint32_t i = 0; i < args->commandBufferCount; i++)
4414 vn_replace_VkCommandBuffer_handle(&((VkCommandBuffer *)args->pCommandBuffers)[i]);
4415 }
4416 }
4417
vn_encode_vkCmdExecuteCommands_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdExecuteCommands * args)4418 static inline void vn_encode_vkCmdExecuteCommands_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdExecuteCommands *args)
4419 {
4420 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdExecuteCommands_EXT});
4421
4422 /* skip args->commandBuffer */
4423 /* skip args->commandBufferCount */
4424 /* skip args->pCommandBuffers */
4425 }
4426
vn_decode_vkCmdPushDescriptorSetKHR_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdPushDescriptorSetKHR * args)4427 static inline void vn_decode_vkCmdPushDescriptorSetKHR_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdPushDescriptorSetKHR *args)
4428 {
4429 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4430 vn_decode_VkPipelineBindPoint(dec, &args->pipelineBindPoint);
4431 vn_decode_VkPipelineLayout_lookup(dec, &args->layout);
4432 vn_decode_uint32_t(dec, &args->set);
4433 vn_decode_uint32_t(dec, &args->descriptorWriteCount);
4434 if (vn_peek_array_size(dec)) {
4435 const uint32_t iter_count = vn_decode_array_size(dec, args->descriptorWriteCount);
4436 args->pDescriptorWrites = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDescriptorWrites) * iter_count);
4437 if (!args->pDescriptorWrites) return;
4438 for (uint32_t i = 0; i < iter_count; i++)
4439 vn_decode_VkWriteDescriptorSet_temp(dec, &((VkWriteDescriptorSet *)args->pDescriptorWrites)[i]);
4440 } else {
4441 vn_decode_array_size(dec, args->descriptorWriteCount);
4442 args->pDescriptorWrites = NULL;
4443 }
4444 }
4445
vn_replace_vkCmdPushDescriptorSetKHR_args_handle(struct vn_command_vkCmdPushDescriptorSetKHR * args)4446 static inline void vn_replace_vkCmdPushDescriptorSetKHR_args_handle(struct vn_command_vkCmdPushDescriptorSetKHR *args)
4447 {
4448 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4449 /* skip args->pipelineBindPoint */
4450 vn_replace_VkPipelineLayout_handle(&args->layout);
4451 /* skip args->set */
4452 /* skip args->descriptorWriteCount */
4453 if (args->pDescriptorWrites) {
4454 for (uint32_t i = 0; i < args->descriptorWriteCount; i++)
4455 vn_replace_VkWriteDescriptorSet_handle(&((VkWriteDescriptorSet *)args->pDescriptorWrites)[i]);
4456 }
4457 }
4458
vn_encode_vkCmdPushDescriptorSetKHR_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdPushDescriptorSetKHR * args)4459 static inline void vn_encode_vkCmdPushDescriptorSetKHR_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdPushDescriptorSetKHR *args)
4460 {
4461 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdPushDescriptorSetKHR_EXT});
4462
4463 /* skip args->commandBuffer */
4464 /* skip args->pipelineBindPoint */
4465 /* skip args->layout */
4466 /* skip args->set */
4467 /* skip args->descriptorWriteCount */
4468 /* skip args->pDescriptorWrites */
4469 }
4470
vn_decode_vkCmdSetDeviceMask_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDeviceMask * args)4471 static inline void vn_decode_vkCmdSetDeviceMask_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDeviceMask *args)
4472 {
4473 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4474 vn_decode_uint32_t(dec, &args->deviceMask);
4475 }
4476
vn_replace_vkCmdSetDeviceMask_args_handle(struct vn_command_vkCmdSetDeviceMask * args)4477 static inline void vn_replace_vkCmdSetDeviceMask_args_handle(struct vn_command_vkCmdSetDeviceMask *args)
4478 {
4479 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4480 /* skip args->deviceMask */
4481 }
4482
vn_encode_vkCmdSetDeviceMask_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDeviceMask * args)4483 static inline void vn_encode_vkCmdSetDeviceMask_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDeviceMask *args)
4484 {
4485 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDeviceMask_EXT});
4486
4487 /* skip args->commandBuffer */
4488 /* skip args->deviceMask */
4489 }
4490
vn_decode_vkCmdDispatchBase_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDispatchBase * args)4491 static inline void vn_decode_vkCmdDispatchBase_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDispatchBase *args)
4492 {
4493 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4494 vn_decode_uint32_t(dec, &args->baseGroupX);
4495 vn_decode_uint32_t(dec, &args->baseGroupY);
4496 vn_decode_uint32_t(dec, &args->baseGroupZ);
4497 vn_decode_uint32_t(dec, &args->groupCountX);
4498 vn_decode_uint32_t(dec, &args->groupCountY);
4499 vn_decode_uint32_t(dec, &args->groupCountZ);
4500 }
4501
vn_replace_vkCmdDispatchBase_args_handle(struct vn_command_vkCmdDispatchBase * args)4502 static inline void vn_replace_vkCmdDispatchBase_args_handle(struct vn_command_vkCmdDispatchBase *args)
4503 {
4504 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4505 /* skip args->baseGroupX */
4506 /* skip args->baseGroupY */
4507 /* skip args->baseGroupZ */
4508 /* skip args->groupCountX */
4509 /* skip args->groupCountY */
4510 /* skip args->groupCountZ */
4511 }
4512
vn_encode_vkCmdDispatchBase_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDispatchBase * args)4513 static inline void vn_encode_vkCmdDispatchBase_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDispatchBase *args)
4514 {
4515 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDispatchBase_EXT});
4516
4517 /* skip args->commandBuffer */
4518 /* skip args->baseGroupX */
4519 /* skip args->baseGroupY */
4520 /* skip args->baseGroupZ */
4521 /* skip args->groupCountX */
4522 /* skip args->groupCountY */
4523 /* skip args->groupCountZ */
4524 }
4525
vn_decode_vkCmdBeginRenderPass2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBeginRenderPass2 * args)4526 static inline void vn_decode_vkCmdBeginRenderPass2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginRenderPass2 *args)
4527 {
4528 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4529 if (vn_decode_simple_pointer(dec)) {
4530 args->pRenderPassBegin = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRenderPassBegin));
4531 if (!args->pRenderPassBegin) return;
4532 vn_decode_VkRenderPassBeginInfo_temp(dec, (VkRenderPassBeginInfo *)args->pRenderPassBegin);
4533 } else {
4534 args->pRenderPassBegin = NULL;
4535 vn_cs_decoder_set_fatal(dec);
4536 }
4537 if (vn_decode_simple_pointer(dec)) {
4538 args->pSubpassBeginInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassBeginInfo));
4539 if (!args->pSubpassBeginInfo) return;
4540 vn_decode_VkSubpassBeginInfo_temp(dec, (VkSubpassBeginInfo *)args->pSubpassBeginInfo);
4541 } else {
4542 args->pSubpassBeginInfo = NULL;
4543 vn_cs_decoder_set_fatal(dec);
4544 }
4545 }
4546
vn_replace_vkCmdBeginRenderPass2_args_handle(struct vn_command_vkCmdBeginRenderPass2 * args)4547 static inline void vn_replace_vkCmdBeginRenderPass2_args_handle(struct vn_command_vkCmdBeginRenderPass2 *args)
4548 {
4549 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4550 if (args->pRenderPassBegin)
4551 vn_replace_VkRenderPassBeginInfo_handle((VkRenderPassBeginInfo *)args->pRenderPassBegin);
4552 if (args->pSubpassBeginInfo)
4553 vn_replace_VkSubpassBeginInfo_handle((VkSubpassBeginInfo *)args->pSubpassBeginInfo);
4554 }
4555
vn_encode_vkCmdBeginRenderPass2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBeginRenderPass2 * args)4556 static inline void vn_encode_vkCmdBeginRenderPass2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginRenderPass2 *args)
4557 {
4558 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginRenderPass2_EXT});
4559
4560 /* skip args->commandBuffer */
4561 /* skip args->pRenderPassBegin */
4562 /* skip args->pSubpassBeginInfo */
4563 }
4564
vn_decode_vkCmdNextSubpass2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdNextSubpass2 * args)4565 static inline void vn_decode_vkCmdNextSubpass2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdNextSubpass2 *args)
4566 {
4567 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4568 if (vn_decode_simple_pointer(dec)) {
4569 args->pSubpassBeginInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassBeginInfo));
4570 if (!args->pSubpassBeginInfo) return;
4571 vn_decode_VkSubpassBeginInfo_temp(dec, (VkSubpassBeginInfo *)args->pSubpassBeginInfo);
4572 } else {
4573 args->pSubpassBeginInfo = NULL;
4574 vn_cs_decoder_set_fatal(dec);
4575 }
4576 if (vn_decode_simple_pointer(dec)) {
4577 args->pSubpassEndInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassEndInfo));
4578 if (!args->pSubpassEndInfo) return;
4579 vn_decode_VkSubpassEndInfo_temp(dec, (VkSubpassEndInfo *)args->pSubpassEndInfo);
4580 } else {
4581 args->pSubpassEndInfo = NULL;
4582 vn_cs_decoder_set_fatal(dec);
4583 }
4584 }
4585
vn_replace_vkCmdNextSubpass2_args_handle(struct vn_command_vkCmdNextSubpass2 * args)4586 static inline void vn_replace_vkCmdNextSubpass2_args_handle(struct vn_command_vkCmdNextSubpass2 *args)
4587 {
4588 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4589 if (args->pSubpassBeginInfo)
4590 vn_replace_VkSubpassBeginInfo_handle((VkSubpassBeginInfo *)args->pSubpassBeginInfo);
4591 if (args->pSubpassEndInfo)
4592 vn_replace_VkSubpassEndInfo_handle((VkSubpassEndInfo *)args->pSubpassEndInfo);
4593 }
4594
vn_encode_vkCmdNextSubpass2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdNextSubpass2 * args)4595 static inline void vn_encode_vkCmdNextSubpass2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdNextSubpass2 *args)
4596 {
4597 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdNextSubpass2_EXT});
4598
4599 /* skip args->commandBuffer */
4600 /* skip args->pSubpassBeginInfo */
4601 /* skip args->pSubpassEndInfo */
4602 }
4603
vn_decode_vkCmdEndRenderPass2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdEndRenderPass2 * args)4604 static inline void vn_decode_vkCmdEndRenderPass2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndRenderPass2 *args)
4605 {
4606 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4607 if (vn_decode_simple_pointer(dec)) {
4608 args->pSubpassEndInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubpassEndInfo));
4609 if (!args->pSubpassEndInfo) return;
4610 vn_decode_VkSubpassEndInfo_temp(dec, (VkSubpassEndInfo *)args->pSubpassEndInfo);
4611 } else {
4612 args->pSubpassEndInfo = NULL;
4613 vn_cs_decoder_set_fatal(dec);
4614 }
4615 }
4616
vn_replace_vkCmdEndRenderPass2_args_handle(struct vn_command_vkCmdEndRenderPass2 * args)4617 static inline void vn_replace_vkCmdEndRenderPass2_args_handle(struct vn_command_vkCmdEndRenderPass2 *args)
4618 {
4619 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4620 if (args->pSubpassEndInfo)
4621 vn_replace_VkSubpassEndInfo_handle((VkSubpassEndInfo *)args->pSubpassEndInfo);
4622 }
4623
vn_encode_vkCmdEndRenderPass2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdEndRenderPass2 * args)4624 static inline void vn_encode_vkCmdEndRenderPass2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndRenderPass2 *args)
4625 {
4626 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndRenderPass2_EXT});
4627
4628 /* skip args->commandBuffer */
4629 /* skip args->pSubpassEndInfo */
4630 }
4631
vn_decode_vkCmdDrawIndirectCount_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawIndirectCount * args)4632 static inline void vn_decode_vkCmdDrawIndirectCount_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndirectCount *args)
4633 {
4634 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4635 vn_decode_VkBuffer_lookup(dec, &args->buffer);
4636 vn_decode_VkDeviceSize(dec, &args->offset);
4637 vn_decode_VkBuffer_lookup(dec, &args->countBuffer);
4638 vn_decode_VkDeviceSize(dec, &args->countBufferOffset);
4639 vn_decode_uint32_t(dec, &args->maxDrawCount);
4640 vn_decode_uint32_t(dec, &args->stride);
4641 }
4642
vn_replace_vkCmdDrawIndirectCount_args_handle(struct vn_command_vkCmdDrawIndirectCount * args)4643 static inline void vn_replace_vkCmdDrawIndirectCount_args_handle(struct vn_command_vkCmdDrawIndirectCount *args)
4644 {
4645 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4646 vn_replace_VkBuffer_handle(&args->buffer);
4647 /* skip args->offset */
4648 vn_replace_VkBuffer_handle(&args->countBuffer);
4649 /* skip args->countBufferOffset */
4650 /* skip args->maxDrawCount */
4651 /* skip args->stride */
4652 }
4653
vn_encode_vkCmdDrawIndirectCount_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawIndirectCount * args)4654 static inline void vn_encode_vkCmdDrawIndirectCount_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndirectCount *args)
4655 {
4656 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndirectCount_EXT});
4657
4658 /* skip args->commandBuffer */
4659 /* skip args->buffer */
4660 /* skip args->offset */
4661 /* skip args->countBuffer */
4662 /* skip args->countBufferOffset */
4663 /* skip args->maxDrawCount */
4664 /* skip args->stride */
4665 }
4666
vn_decode_vkCmdDrawIndexedIndirectCount_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawIndexedIndirectCount * args)4667 static inline void vn_decode_vkCmdDrawIndexedIndirectCount_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndexedIndirectCount *args)
4668 {
4669 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4670 vn_decode_VkBuffer_lookup(dec, &args->buffer);
4671 vn_decode_VkDeviceSize(dec, &args->offset);
4672 vn_decode_VkBuffer_lookup(dec, &args->countBuffer);
4673 vn_decode_VkDeviceSize(dec, &args->countBufferOffset);
4674 vn_decode_uint32_t(dec, &args->maxDrawCount);
4675 vn_decode_uint32_t(dec, &args->stride);
4676 }
4677
vn_replace_vkCmdDrawIndexedIndirectCount_args_handle(struct vn_command_vkCmdDrawIndexedIndirectCount * args)4678 static inline void vn_replace_vkCmdDrawIndexedIndirectCount_args_handle(struct vn_command_vkCmdDrawIndexedIndirectCount *args)
4679 {
4680 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4681 vn_replace_VkBuffer_handle(&args->buffer);
4682 /* skip args->offset */
4683 vn_replace_VkBuffer_handle(&args->countBuffer);
4684 /* skip args->countBufferOffset */
4685 /* skip args->maxDrawCount */
4686 /* skip args->stride */
4687 }
4688
vn_encode_vkCmdDrawIndexedIndirectCount_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawIndexedIndirectCount * args)4689 static inline void vn_encode_vkCmdDrawIndexedIndirectCount_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndexedIndirectCount *args)
4690 {
4691 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndexedIndirectCount_EXT});
4692
4693 /* skip args->commandBuffer */
4694 /* skip args->buffer */
4695 /* skip args->offset */
4696 /* skip args->countBuffer */
4697 /* skip args->countBufferOffset */
4698 /* skip args->maxDrawCount */
4699 /* skip args->stride */
4700 }
4701
vn_decode_vkCmdBindTransformFeedbackBuffersEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBindTransformFeedbackBuffersEXT * args)4702 static inline void vn_decode_vkCmdBindTransformFeedbackBuffersEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindTransformFeedbackBuffersEXT *args)
4703 {
4704 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4705 vn_decode_uint32_t(dec, &args->firstBinding);
4706 vn_decode_uint32_t(dec, &args->bindingCount);
4707 if (vn_peek_array_size(dec)) {
4708 const uint32_t iter_count = vn_decode_array_size(dec, args->bindingCount);
4709 args->pBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBuffers) * iter_count);
4710 if (!args->pBuffers) return;
4711 for (uint32_t i = 0; i < iter_count; i++)
4712 vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pBuffers)[i]);
4713 } else {
4714 vn_decode_array_size(dec, args->bindingCount);
4715 args->pBuffers = NULL;
4716 }
4717 if (vn_peek_array_size(dec)) {
4718 const size_t array_size = vn_decode_array_size(dec, args->bindingCount);
4719 args->pOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pOffsets) * array_size);
4720 if (!args->pOffsets) return;
4721 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pOffsets, array_size);
4722 } else {
4723 vn_decode_array_size(dec, args->bindingCount);
4724 args->pOffsets = NULL;
4725 }
4726 if (vn_peek_array_size(dec)) {
4727 const size_t array_size = vn_decode_array_size(dec, args->bindingCount);
4728 args->pSizes = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSizes) * array_size);
4729 if (!args->pSizes) return;
4730 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pSizes, array_size);
4731 } else {
4732 vn_decode_array_size_unchecked(dec);
4733 args->pSizes = NULL;
4734 }
4735 }
4736
vn_replace_vkCmdBindTransformFeedbackBuffersEXT_args_handle(struct vn_command_vkCmdBindTransformFeedbackBuffersEXT * args)4737 static inline void vn_replace_vkCmdBindTransformFeedbackBuffersEXT_args_handle(struct vn_command_vkCmdBindTransformFeedbackBuffersEXT *args)
4738 {
4739 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4740 /* skip args->firstBinding */
4741 /* skip args->bindingCount */
4742 if (args->pBuffers) {
4743 for (uint32_t i = 0; i < args->bindingCount; i++)
4744 vn_replace_VkBuffer_handle(&((VkBuffer *)args->pBuffers)[i]);
4745 }
4746 /* skip args->pOffsets */
4747 /* skip args->pSizes */
4748 }
4749
vn_encode_vkCmdBindTransformFeedbackBuffersEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBindTransformFeedbackBuffersEXT * args)4750 static inline void vn_encode_vkCmdBindTransformFeedbackBuffersEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindTransformFeedbackBuffersEXT *args)
4751 {
4752 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT});
4753
4754 /* skip args->commandBuffer */
4755 /* skip args->firstBinding */
4756 /* skip args->bindingCount */
4757 /* skip args->pBuffers */
4758 /* skip args->pOffsets */
4759 /* skip args->pSizes */
4760 }
4761
vn_decode_vkCmdBeginTransformFeedbackEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBeginTransformFeedbackEXT * args)4762 static inline void vn_decode_vkCmdBeginTransformFeedbackEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginTransformFeedbackEXT *args)
4763 {
4764 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4765 vn_decode_uint32_t(dec, &args->firstCounterBuffer);
4766 vn_decode_uint32_t(dec, &args->counterBufferCount);
4767 if (vn_peek_array_size(dec)) {
4768 const uint32_t iter_count = vn_decode_array_size(dec, args->counterBufferCount);
4769 args->pCounterBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBuffers) * iter_count);
4770 if (!args->pCounterBuffers) return;
4771 for (uint32_t i = 0; i < iter_count; i++)
4772 vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pCounterBuffers)[i]);
4773 } else {
4774 vn_decode_array_size_unchecked(dec);
4775 args->pCounterBuffers = NULL;
4776 }
4777 if (vn_peek_array_size(dec)) {
4778 const size_t array_size = vn_decode_array_size(dec, args->counterBufferCount);
4779 args->pCounterBufferOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBufferOffsets) * array_size);
4780 if (!args->pCounterBufferOffsets) return;
4781 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pCounterBufferOffsets, array_size);
4782 } else {
4783 vn_decode_array_size_unchecked(dec);
4784 args->pCounterBufferOffsets = NULL;
4785 }
4786 }
4787
vn_replace_vkCmdBeginTransformFeedbackEXT_args_handle(struct vn_command_vkCmdBeginTransformFeedbackEXT * args)4788 static inline void vn_replace_vkCmdBeginTransformFeedbackEXT_args_handle(struct vn_command_vkCmdBeginTransformFeedbackEXT *args)
4789 {
4790 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4791 /* skip args->firstCounterBuffer */
4792 /* skip args->counterBufferCount */
4793 if (args->pCounterBuffers) {
4794 for (uint32_t i = 0; i < args->counterBufferCount; i++)
4795 vn_replace_VkBuffer_handle(&((VkBuffer *)args->pCounterBuffers)[i]);
4796 }
4797 /* skip args->pCounterBufferOffsets */
4798 }
4799
vn_encode_vkCmdBeginTransformFeedbackEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBeginTransformFeedbackEXT * args)4800 static inline void vn_encode_vkCmdBeginTransformFeedbackEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginTransformFeedbackEXT *args)
4801 {
4802 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT});
4803
4804 /* skip args->commandBuffer */
4805 /* skip args->firstCounterBuffer */
4806 /* skip args->counterBufferCount */
4807 /* skip args->pCounterBuffers */
4808 /* skip args->pCounterBufferOffsets */
4809 }
4810
vn_decode_vkCmdEndTransformFeedbackEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdEndTransformFeedbackEXT * args)4811 static inline void vn_decode_vkCmdEndTransformFeedbackEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndTransformFeedbackEXT *args)
4812 {
4813 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4814 vn_decode_uint32_t(dec, &args->firstCounterBuffer);
4815 vn_decode_uint32_t(dec, &args->counterBufferCount);
4816 if (vn_peek_array_size(dec)) {
4817 const uint32_t iter_count = vn_decode_array_size(dec, args->counterBufferCount);
4818 args->pCounterBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBuffers) * iter_count);
4819 if (!args->pCounterBuffers) return;
4820 for (uint32_t i = 0; i < iter_count; i++)
4821 vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pCounterBuffers)[i]);
4822 } else {
4823 vn_decode_array_size_unchecked(dec);
4824 args->pCounterBuffers = NULL;
4825 }
4826 if (vn_peek_array_size(dec)) {
4827 const size_t array_size = vn_decode_array_size(dec, args->counterBufferCount);
4828 args->pCounterBufferOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCounterBufferOffsets) * array_size);
4829 if (!args->pCounterBufferOffsets) return;
4830 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pCounterBufferOffsets, array_size);
4831 } else {
4832 vn_decode_array_size_unchecked(dec);
4833 args->pCounterBufferOffsets = NULL;
4834 }
4835 }
4836
vn_replace_vkCmdEndTransformFeedbackEXT_args_handle(struct vn_command_vkCmdEndTransformFeedbackEXT * args)4837 static inline void vn_replace_vkCmdEndTransformFeedbackEXT_args_handle(struct vn_command_vkCmdEndTransformFeedbackEXT *args)
4838 {
4839 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4840 /* skip args->firstCounterBuffer */
4841 /* skip args->counterBufferCount */
4842 if (args->pCounterBuffers) {
4843 for (uint32_t i = 0; i < args->counterBufferCount; i++)
4844 vn_replace_VkBuffer_handle(&((VkBuffer *)args->pCounterBuffers)[i]);
4845 }
4846 /* skip args->pCounterBufferOffsets */
4847 }
4848
vn_encode_vkCmdEndTransformFeedbackEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdEndTransformFeedbackEXT * args)4849 static inline void vn_encode_vkCmdEndTransformFeedbackEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndTransformFeedbackEXT *args)
4850 {
4851 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT});
4852
4853 /* skip args->commandBuffer */
4854 /* skip args->firstCounterBuffer */
4855 /* skip args->counterBufferCount */
4856 /* skip args->pCounterBuffers */
4857 /* skip args->pCounterBufferOffsets */
4858 }
4859
vn_decode_vkCmdBeginQueryIndexedEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBeginQueryIndexedEXT * args)4860 static inline void vn_decode_vkCmdBeginQueryIndexedEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginQueryIndexedEXT *args)
4861 {
4862 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4863 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
4864 vn_decode_uint32_t(dec, &args->query);
4865 vn_decode_VkFlags(dec, &args->flags);
4866 vn_decode_uint32_t(dec, &args->index);
4867 }
4868
vn_replace_vkCmdBeginQueryIndexedEXT_args_handle(struct vn_command_vkCmdBeginQueryIndexedEXT * args)4869 static inline void vn_replace_vkCmdBeginQueryIndexedEXT_args_handle(struct vn_command_vkCmdBeginQueryIndexedEXT *args)
4870 {
4871 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4872 vn_replace_VkQueryPool_handle(&args->queryPool);
4873 /* skip args->query */
4874 /* skip args->flags */
4875 /* skip args->index */
4876 }
4877
vn_encode_vkCmdBeginQueryIndexedEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBeginQueryIndexedEXT * args)4878 static inline void vn_encode_vkCmdBeginQueryIndexedEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginQueryIndexedEXT *args)
4879 {
4880 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginQueryIndexedEXT_EXT});
4881
4882 /* skip args->commandBuffer */
4883 /* skip args->queryPool */
4884 /* skip args->query */
4885 /* skip args->flags */
4886 /* skip args->index */
4887 }
4888
vn_decode_vkCmdEndQueryIndexedEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdEndQueryIndexedEXT * args)4889 static inline void vn_decode_vkCmdEndQueryIndexedEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndQueryIndexedEXT *args)
4890 {
4891 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4892 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
4893 vn_decode_uint32_t(dec, &args->query);
4894 vn_decode_uint32_t(dec, &args->index);
4895 }
4896
vn_replace_vkCmdEndQueryIndexedEXT_args_handle(struct vn_command_vkCmdEndQueryIndexedEXT * args)4897 static inline void vn_replace_vkCmdEndQueryIndexedEXT_args_handle(struct vn_command_vkCmdEndQueryIndexedEXT *args)
4898 {
4899 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4900 vn_replace_VkQueryPool_handle(&args->queryPool);
4901 /* skip args->query */
4902 /* skip args->index */
4903 }
4904
vn_encode_vkCmdEndQueryIndexedEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdEndQueryIndexedEXT * args)4905 static inline void vn_encode_vkCmdEndQueryIndexedEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndQueryIndexedEXT *args)
4906 {
4907 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndQueryIndexedEXT_EXT});
4908
4909 /* skip args->commandBuffer */
4910 /* skip args->queryPool */
4911 /* skip args->query */
4912 /* skip args->index */
4913 }
4914
vn_decode_vkCmdDrawIndirectByteCountEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdDrawIndirectByteCountEXT * args)4915 static inline void vn_decode_vkCmdDrawIndirectByteCountEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdDrawIndirectByteCountEXT *args)
4916 {
4917 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4918 vn_decode_uint32_t(dec, &args->instanceCount);
4919 vn_decode_uint32_t(dec, &args->firstInstance);
4920 vn_decode_VkBuffer_lookup(dec, &args->counterBuffer);
4921 vn_decode_VkDeviceSize(dec, &args->counterBufferOffset);
4922 vn_decode_uint32_t(dec, &args->counterOffset);
4923 vn_decode_uint32_t(dec, &args->vertexStride);
4924 }
4925
vn_replace_vkCmdDrawIndirectByteCountEXT_args_handle(struct vn_command_vkCmdDrawIndirectByteCountEXT * args)4926 static inline void vn_replace_vkCmdDrawIndirectByteCountEXT_args_handle(struct vn_command_vkCmdDrawIndirectByteCountEXT *args)
4927 {
4928 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4929 /* skip args->instanceCount */
4930 /* skip args->firstInstance */
4931 vn_replace_VkBuffer_handle(&args->counterBuffer);
4932 /* skip args->counterBufferOffset */
4933 /* skip args->counterOffset */
4934 /* skip args->vertexStride */
4935 }
4936
vn_encode_vkCmdDrawIndirectByteCountEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdDrawIndirectByteCountEXT * args)4937 static inline void vn_encode_vkCmdDrawIndirectByteCountEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdDrawIndirectByteCountEXT *args)
4938 {
4939 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdDrawIndirectByteCountEXT_EXT});
4940
4941 /* skip args->commandBuffer */
4942 /* skip args->instanceCount */
4943 /* skip args->firstInstance */
4944 /* skip args->counterBuffer */
4945 /* skip args->counterBufferOffset */
4946 /* skip args->counterOffset */
4947 /* skip args->vertexStride */
4948 }
4949
vn_decode_vkCmdSetLineStippleEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetLineStippleEXT * args)4950 static inline void vn_decode_vkCmdSetLineStippleEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetLineStippleEXT *args)
4951 {
4952 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4953 vn_decode_uint32_t(dec, &args->lineStippleFactor);
4954 vn_decode_uint16_t(dec, &args->lineStipplePattern);
4955 }
4956
vn_replace_vkCmdSetLineStippleEXT_args_handle(struct vn_command_vkCmdSetLineStippleEXT * args)4957 static inline void vn_replace_vkCmdSetLineStippleEXT_args_handle(struct vn_command_vkCmdSetLineStippleEXT *args)
4958 {
4959 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4960 /* skip args->lineStippleFactor */
4961 /* skip args->lineStipplePattern */
4962 }
4963
vn_encode_vkCmdSetLineStippleEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetLineStippleEXT * args)4964 static inline void vn_encode_vkCmdSetLineStippleEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetLineStippleEXT *args)
4965 {
4966 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetLineStippleEXT_EXT});
4967
4968 /* skip args->commandBuffer */
4969 /* skip args->lineStippleFactor */
4970 /* skip args->lineStipplePattern */
4971 }
4972
vn_decode_vkCmdSetCullMode_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetCullMode * args)4973 static inline void vn_decode_vkCmdSetCullMode_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetCullMode *args)
4974 {
4975 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4976 vn_decode_VkFlags(dec, &args->cullMode);
4977 }
4978
vn_replace_vkCmdSetCullMode_args_handle(struct vn_command_vkCmdSetCullMode * args)4979 static inline void vn_replace_vkCmdSetCullMode_args_handle(struct vn_command_vkCmdSetCullMode *args)
4980 {
4981 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
4982 /* skip args->cullMode */
4983 }
4984
vn_encode_vkCmdSetCullMode_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetCullMode * args)4985 static inline void vn_encode_vkCmdSetCullMode_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetCullMode *args)
4986 {
4987 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetCullMode_EXT});
4988
4989 /* skip args->commandBuffer */
4990 /* skip args->cullMode */
4991 }
4992
vn_decode_vkCmdSetFrontFace_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetFrontFace * args)4993 static inline void vn_decode_vkCmdSetFrontFace_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetFrontFace *args)
4994 {
4995 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
4996 vn_decode_VkFrontFace(dec, &args->frontFace);
4997 }
4998
vn_replace_vkCmdSetFrontFace_args_handle(struct vn_command_vkCmdSetFrontFace * args)4999 static inline void vn_replace_vkCmdSetFrontFace_args_handle(struct vn_command_vkCmdSetFrontFace *args)
5000 {
5001 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5002 /* skip args->frontFace */
5003 }
5004
vn_encode_vkCmdSetFrontFace_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetFrontFace * args)5005 static inline void vn_encode_vkCmdSetFrontFace_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetFrontFace *args)
5006 {
5007 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT});
5008
5009 /* skip args->commandBuffer */
5010 /* skip args->frontFace */
5011 }
5012
vn_decode_vkCmdSetPrimitiveTopology_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetPrimitiveTopology * args)5013 static inline void vn_decode_vkCmdSetPrimitiveTopology_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetPrimitiveTopology *args)
5014 {
5015 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5016 vn_decode_VkPrimitiveTopology(dec, &args->primitiveTopology);
5017 }
5018
vn_replace_vkCmdSetPrimitiveTopology_args_handle(struct vn_command_vkCmdSetPrimitiveTopology * args)5019 static inline void vn_replace_vkCmdSetPrimitiveTopology_args_handle(struct vn_command_vkCmdSetPrimitiveTopology *args)
5020 {
5021 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5022 /* skip args->primitiveTopology */
5023 }
5024
vn_encode_vkCmdSetPrimitiveTopology_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetPrimitiveTopology * args)5025 static inline void vn_encode_vkCmdSetPrimitiveTopology_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetPrimitiveTopology *args)
5026 {
5027 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT});
5028
5029 /* skip args->commandBuffer */
5030 /* skip args->primitiveTopology */
5031 }
5032
vn_decode_vkCmdSetViewportWithCount_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetViewportWithCount * args)5033 static inline void vn_decode_vkCmdSetViewportWithCount_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetViewportWithCount *args)
5034 {
5035 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5036 vn_decode_uint32_t(dec, &args->viewportCount);
5037 if (vn_peek_array_size(dec)) {
5038 const uint32_t iter_count = vn_decode_array_size(dec, args->viewportCount);
5039 args->pViewports = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pViewports) * iter_count);
5040 if (!args->pViewports) return;
5041 for (uint32_t i = 0; i < iter_count; i++)
5042 vn_decode_VkViewport_temp(dec, &((VkViewport *)args->pViewports)[i]);
5043 } else {
5044 vn_decode_array_size(dec, args->viewportCount);
5045 args->pViewports = NULL;
5046 }
5047 }
5048
vn_replace_vkCmdSetViewportWithCount_args_handle(struct vn_command_vkCmdSetViewportWithCount * args)5049 static inline void vn_replace_vkCmdSetViewportWithCount_args_handle(struct vn_command_vkCmdSetViewportWithCount *args)
5050 {
5051 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5052 /* skip args->viewportCount */
5053 if (args->pViewports) {
5054 for (uint32_t i = 0; i < args->viewportCount; i++)
5055 vn_replace_VkViewport_handle(&((VkViewport *)args->pViewports)[i]);
5056 }
5057 }
5058
vn_encode_vkCmdSetViewportWithCount_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetViewportWithCount * args)5059 static inline void vn_encode_vkCmdSetViewportWithCount_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetViewportWithCount *args)
5060 {
5061 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT});
5062
5063 /* skip args->commandBuffer */
5064 /* skip args->viewportCount */
5065 /* skip args->pViewports */
5066 }
5067
vn_decode_vkCmdSetScissorWithCount_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetScissorWithCount * args)5068 static inline void vn_decode_vkCmdSetScissorWithCount_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetScissorWithCount *args)
5069 {
5070 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5071 vn_decode_uint32_t(dec, &args->scissorCount);
5072 if (vn_peek_array_size(dec)) {
5073 const uint32_t iter_count = vn_decode_array_size(dec, args->scissorCount);
5074 args->pScissors = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pScissors) * iter_count);
5075 if (!args->pScissors) return;
5076 for (uint32_t i = 0; i < iter_count; i++)
5077 vn_decode_VkRect2D_temp(dec, &((VkRect2D *)args->pScissors)[i]);
5078 } else {
5079 vn_decode_array_size(dec, args->scissorCount);
5080 args->pScissors = NULL;
5081 }
5082 }
5083
vn_replace_vkCmdSetScissorWithCount_args_handle(struct vn_command_vkCmdSetScissorWithCount * args)5084 static inline void vn_replace_vkCmdSetScissorWithCount_args_handle(struct vn_command_vkCmdSetScissorWithCount *args)
5085 {
5086 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5087 /* skip args->scissorCount */
5088 if (args->pScissors) {
5089 for (uint32_t i = 0; i < args->scissorCount; i++)
5090 vn_replace_VkRect2D_handle(&((VkRect2D *)args->pScissors)[i]);
5091 }
5092 }
5093
vn_encode_vkCmdSetScissorWithCount_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetScissorWithCount * args)5094 static inline void vn_encode_vkCmdSetScissorWithCount_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetScissorWithCount *args)
5095 {
5096 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT});
5097
5098 /* skip args->commandBuffer */
5099 /* skip args->scissorCount */
5100 /* skip args->pScissors */
5101 }
5102
vn_decode_vkCmdBindVertexBuffers2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBindVertexBuffers2 * args)5103 static inline void vn_decode_vkCmdBindVertexBuffers2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBindVertexBuffers2 *args)
5104 {
5105 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5106 vn_decode_uint32_t(dec, &args->firstBinding);
5107 vn_decode_uint32_t(dec, &args->bindingCount);
5108 if (vn_peek_array_size(dec)) {
5109 const uint32_t iter_count = vn_decode_array_size(dec, args->bindingCount);
5110 args->pBuffers = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBuffers) * iter_count);
5111 if (!args->pBuffers) return;
5112 for (uint32_t i = 0; i < iter_count; i++)
5113 vn_decode_VkBuffer_lookup(dec, &((VkBuffer *)args->pBuffers)[i]);
5114 } else {
5115 vn_decode_array_size(dec, args->bindingCount);
5116 args->pBuffers = NULL;
5117 }
5118 if (vn_peek_array_size(dec)) {
5119 const size_t array_size = vn_decode_array_size(dec, args->bindingCount);
5120 args->pOffsets = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pOffsets) * array_size);
5121 if (!args->pOffsets) return;
5122 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pOffsets, array_size);
5123 } else {
5124 vn_decode_array_size(dec, args->bindingCount);
5125 args->pOffsets = NULL;
5126 }
5127 if (vn_peek_array_size(dec)) {
5128 const size_t array_size = vn_decode_array_size(dec, args->bindingCount);
5129 args->pSizes = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSizes) * array_size);
5130 if (!args->pSizes) return;
5131 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pSizes, array_size);
5132 } else {
5133 vn_decode_array_size_unchecked(dec);
5134 args->pSizes = NULL;
5135 }
5136 if (vn_peek_array_size(dec)) {
5137 const size_t array_size = vn_decode_array_size(dec, args->bindingCount);
5138 args->pStrides = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pStrides) * array_size);
5139 if (!args->pStrides) return;
5140 vn_decode_VkDeviceSize_array(dec, (VkDeviceSize *)args->pStrides, array_size);
5141 } else {
5142 vn_decode_array_size_unchecked(dec);
5143 args->pStrides = NULL;
5144 }
5145 }
5146
vn_replace_vkCmdBindVertexBuffers2_args_handle(struct vn_command_vkCmdBindVertexBuffers2 * args)5147 static inline void vn_replace_vkCmdBindVertexBuffers2_args_handle(struct vn_command_vkCmdBindVertexBuffers2 *args)
5148 {
5149 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5150 /* skip args->firstBinding */
5151 /* skip args->bindingCount */
5152 if (args->pBuffers) {
5153 for (uint32_t i = 0; i < args->bindingCount; i++)
5154 vn_replace_VkBuffer_handle(&((VkBuffer *)args->pBuffers)[i]);
5155 }
5156 /* skip args->pOffsets */
5157 /* skip args->pSizes */
5158 /* skip args->pStrides */
5159 }
5160
vn_encode_vkCmdBindVertexBuffers2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBindVertexBuffers2 * args)5161 static inline void vn_encode_vkCmdBindVertexBuffers2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBindVertexBuffers2 *args)
5162 {
5163 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT});
5164
5165 /* skip args->commandBuffer */
5166 /* skip args->firstBinding */
5167 /* skip args->bindingCount */
5168 /* skip args->pBuffers */
5169 /* skip args->pOffsets */
5170 /* skip args->pSizes */
5171 /* skip args->pStrides */
5172 }
5173
vn_decode_vkCmdSetDepthTestEnable_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDepthTestEnable * args)5174 static inline void vn_decode_vkCmdSetDepthTestEnable_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthTestEnable *args)
5175 {
5176 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5177 vn_decode_VkBool32(dec, &args->depthTestEnable);
5178 }
5179
vn_replace_vkCmdSetDepthTestEnable_args_handle(struct vn_command_vkCmdSetDepthTestEnable * args)5180 static inline void vn_replace_vkCmdSetDepthTestEnable_args_handle(struct vn_command_vkCmdSetDepthTestEnable *args)
5181 {
5182 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5183 /* skip args->depthTestEnable */
5184 }
5185
vn_encode_vkCmdSetDepthTestEnable_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDepthTestEnable * args)5186 static inline void vn_encode_vkCmdSetDepthTestEnable_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthTestEnable *args)
5187 {
5188 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT});
5189
5190 /* skip args->commandBuffer */
5191 /* skip args->depthTestEnable */
5192 }
5193
vn_decode_vkCmdSetDepthWriteEnable_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDepthWriteEnable * args)5194 static inline void vn_decode_vkCmdSetDepthWriteEnable_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthWriteEnable *args)
5195 {
5196 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5197 vn_decode_VkBool32(dec, &args->depthWriteEnable);
5198 }
5199
vn_replace_vkCmdSetDepthWriteEnable_args_handle(struct vn_command_vkCmdSetDepthWriteEnable * args)5200 static inline void vn_replace_vkCmdSetDepthWriteEnable_args_handle(struct vn_command_vkCmdSetDepthWriteEnable *args)
5201 {
5202 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5203 /* skip args->depthWriteEnable */
5204 }
5205
vn_encode_vkCmdSetDepthWriteEnable_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDepthWriteEnable * args)5206 static inline void vn_encode_vkCmdSetDepthWriteEnable_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthWriteEnable *args)
5207 {
5208 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT});
5209
5210 /* skip args->commandBuffer */
5211 /* skip args->depthWriteEnable */
5212 }
5213
vn_decode_vkCmdSetDepthCompareOp_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDepthCompareOp * args)5214 static inline void vn_decode_vkCmdSetDepthCompareOp_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthCompareOp *args)
5215 {
5216 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5217 vn_decode_VkCompareOp(dec, &args->depthCompareOp);
5218 }
5219
vn_replace_vkCmdSetDepthCompareOp_args_handle(struct vn_command_vkCmdSetDepthCompareOp * args)5220 static inline void vn_replace_vkCmdSetDepthCompareOp_args_handle(struct vn_command_vkCmdSetDepthCompareOp *args)
5221 {
5222 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5223 /* skip args->depthCompareOp */
5224 }
5225
vn_encode_vkCmdSetDepthCompareOp_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDepthCompareOp * args)5226 static inline void vn_encode_vkCmdSetDepthCompareOp_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthCompareOp *args)
5227 {
5228 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT});
5229
5230 /* skip args->commandBuffer */
5231 /* skip args->depthCompareOp */
5232 }
5233
vn_decode_vkCmdSetDepthBoundsTestEnable_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDepthBoundsTestEnable * args)5234 static inline void vn_decode_vkCmdSetDepthBoundsTestEnable_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthBoundsTestEnable *args)
5235 {
5236 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5237 vn_decode_VkBool32(dec, &args->depthBoundsTestEnable);
5238 }
5239
vn_replace_vkCmdSetDepthBoundsTestEnable_args_handle(struct vn_command_vkCmdSetDepthBoundsTestEnable * args)5240 static inline void vn_replace_vkCmdSetDepthBoundsTestEnable_args_handle(struct vn_command_vkCmdSetDepthBoundsTestEnable *args)
5241 {
5242 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5243 /* skip args->depthBoundsTestEnable */
5244 }
5245
vn_encode_vkCmdSetDepthBoundsTestEnable_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDepthBoundsTestEnable * args)5246 static inline void vn_encode_vkCmdSetDepthBoundsTestEnable_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthBoundsTestEnable *args)
5247 {
5248 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT});
5249
5250 /* skip args->commandBuffer */
5251 /* skip args->depthBoundsTestEnable */
5252 }
5253
vn_decode_vkCmdSetStencilTestEnable_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetStencilTestEnable * args)5254 static inline void vn_decode_vkCmdSetStencilTestEnable_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilTestEnable *args)
5255 {
5256 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5257 vn_decode_VkBool32(dec, &args->stencilTestEnable);
5258 }
5259
vn_replace_vkCmdSetStencilTestEnable_args_handle(struct vn_command_vkCmdSetStencilTestEnable * args)5260 static inline void vn_replace_vkCmdSetStencilTestEnable_args_handle(struct vn_command_vkCmdSetStencilTestEnable *args)
5261 {
5262 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5263 /* skip args->stencilTestEnable */
5264 }
5265
vn_encode_vkCmdSetStencilTestEnable_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetStencilTestEnable * args)5266 static inline void vn_encode_vkCmdSetStencilTestEnable_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilTestEnable *args)
5267 {
5268 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT});
5269
5270 /* skip args->commandBuffer */
5271 /* skip args->stencilTestEnable */
5272 }
5273
vn_decode_vkCmdSetStencilOp_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetStencilOp * args)5274 static inline void vn_decode_vkCmdSetStencilOp_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetStencilOp *args)
5275 {
5276 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5277 vn_decode_VkFlags(dec, &args->faceMask);
5278 vn_decode_VkStencilOp(dec, &args->failOp);
5279 vn_decode_VkStencilOp(dec, &args->passOp);
5280 vn_decode_VkStencilOp(dec, &args->depthFailOp);
5281 vn_decode_VkCompareOp(dec, &args->compareOp);
5282 }
5283
vn_replace_vkCmdSetStencilOp_args_handle(struct vn_command_vkCmdSetStencilOp * args)5284 static inline void vn_replace_vkCmdSetStencilOp_args_handle(struct vn_command_vkCmdSetStencilOp *args)
5285 {
5286 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5287 /* skip args->faceMask */
5288 /* skip args->failOp */
5289 /* skip args->passOp */
5290 /* skip args->depthFailOp */
5291 /* skip args->compareOp */
5292 }
5293
vn_encode_vkCmdSetStencilOp_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetStencilOp * args)5294 static inline void vn_encode_vkCmdSetStencilOp_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetStencilOp *args)
5295 {
5296 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT});
5297
5298 /* skip args->commandBuffer */
5299 /* skip args->faceMask */
5300 /* skip args->failOp */
5301 /* skip args->passOp */
5302 /* skip args->depthFailOp */
5303 /* skip args->compareOp */
5304 }
5305
vn_decode_vkCmdSetPatchControlPointsEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetPatchControlPointsEXT * args)5306 static inline void vn_decode_vkCmdSetPatchControlPointsEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetPatchControlPointsEXT *args)
5307 {
5308 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5309 vn_decode_uint32_t(dec, &args->patchControlPoints);
5310 }
5311
vn_replace_vkCmdSetPatchControlPointsEXT_args_handle(struct vn_command_vkCmdSetPatchControlPointsEXT * args)5312 static inline void vn_replace_vkCmdSetPatchControlPointsEXT_args_handle(struct vn_command_vkCmdSetPatchControlPointsEXT *args)
5313 {
5314 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5315 /* skip args->patchControlPoints */
5316 }
5317
vn_encode_vkCmdSetPatchControlPointsEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetPatchControlPointsEXT * args)5318 static inline void vn_encode_vkCmdSetPatchControlPointsEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetPatchControlPointsEXT *args)
5319 {
5320 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT});
5321
5322 /* skip args->commandBuffer */
5323 /* skip args->patchControlPoints */
5324 }
5325
vn_decode_vkCmdSetRasterizerDiscardEnable_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetRasterizerDiscardEnable * args)5326 static inline void vn_decode_vkCmdSetRasterizerDiscardEnable_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetRasterizerDiscardEnable *args)
5327 {
5328 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5329 vn_decode_VkBool32(dec, &args->rasterizerDiscardEnable);
5330 }
5331
vn_replace_vkCmdSetRasterizerDiscardEnable_args_handle(struct vn_command_vkCmdSetRasterizerDiscardEnable * args)5332 static inline void vn_replace_vkCmdSetRasterizerDiscardEnable_args_handle(struct vn_command_vkCmdSetRasterizerDiscardEnable *args)
5333 {
5334 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5335 /* skip args->rasterizerDiscardEnable */
5336 }
5337
vn_encode_vkCmdSetRasterizerDiscardEnable_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetRasterizerDiscardEnable * args)5338 static inline void vn_encode_vkCmdSetRasterizerDiscardEnable_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetRasterizerDiscardEnable *args)
5339 {
5340 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT});
5341
5342 /* skip args->commandBuffer */
5343 /* skip args->rasterizerDiscardEnable */
5344 }
5345
vn_decode_vkCmdSetDepthBiasEnable_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetDepthBiasEnable * args)5346 static inline void vn_decode_vkCmdSetDepthBiasEnable_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetDepthBiasEnable *args)
5347 {
5348 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5349 vn_decode_VkBool32(dec, &args->depthBiasEnable);
5350 }
5351
vn_replace_vkCmdSetDepthBiasEnable_args_handle(struct vn_command_vkCmdSetDepthBiasEnable * args)5352 static inline void vn_replace_vkCmdSetDepthBiasEnable_args_handle(struct vn_command_vkCmdSetDepthBiasEnable *args)
5353 {
5354 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5355 /* skip args->depthBiasEnable */
5356 }
5357
vn_encode_vkCmdSetDepthBiasEnable_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetDepthBiasEnable * args)5358 static inline void vn_encode_vkCmdSetDepthBiasEnable_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetDepthBiasEnable *args)
5359 {
5360 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT});
5361
5362 /* skip args->commandBuffer */
5363 /* skip args->depthBiasEnable */
5364 }
5365
vn_decode_vkCmdSetLogicOpEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetLogicOpEXT * args)5366 static inline void vn_decode_vkCmdSetLogicOpEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetLogicOpEXT *args)
5367 {
5368 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5369 vn_decode_VkLogicOp(dec, &args->logicOp);
5370 }
5371
vn_replace_vkCmdSetLogicOpEXT_args_handle(struct vn_command_vkCmdSetLogicOpEXT * args)5372 static inline void vn_replace_vkCmdSetLogicOpEXT_args_handle(struct vn_command_vkCmdSetLogicOpEXT *args)
5373 {
5374 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5375 /* skip args->logicOp */
5376 }
5377
vn_encode_vkCmdSetLogicOpEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetLogicOpEXT * args)5378 static inline void vn_encode_vkCmdSetLogicOpEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetLogicOpEXT *args)
5379 {
5380 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT});
5381
5382 /* skip args->commandBuffer */
5383 /* skip args->logicOp */
5384 }
5385
vn_decode_vkCmdSetPrimitiveRestartEnable_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetPrimitiveRestartEnable * args)5386 static inline void vn_decode_vkCmdSetPrimitiveRestartEnable_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetPrimitiveRestartEnable *args)
5387 {
5388 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5389 vn_decode_VkBool32(dec, &args->primitiveRestartEnable);
5390 }
5391
vn_replace_vkCmdSetPrimitiveRestartEnable_args_handle(struct vn_command_vkCmdSetPrimitiveRestartEnable * args)5392 static inline void vn_replace_vkCmdSetPrimitiveRestartEnable_args_handle(struct vn_command_vkCmdSetPrimitiveRestartEnable *args)
5393 {
5394 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5395 /* skip args->primitiveRestartEnable */
5396 }
5397
vn_encode_vkCmdSetPrimitiveRestartEnable_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetPrimitiveRestartEnable * args)5398 static inline void vn_encode_vkCmdSetPrimitiveRestartEnable_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetPrimitiveRestartEnable *args)
5399 {
5400 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT});
5401
5402 /* skip args->commandBuffer */
5403 /* skip args->primitiveRestartEnable */
5404 }
5405
vn_decode_vkCmdCopyBuffer2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyBuffer2 * args)5406 static inline void vn_decode_vkCmdCopyBuffer2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyBuffer2 *args)
5407 {
5408 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5409 if (vn_decode_simple_pointer(dec)) {
5410 args->pCopyBufferInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCopyBufferInfo));
5411 if (!args->pCopyBufferInfo) return;
5412 vn_decode_VkCopyBufferInfo2_temp(dec, (VkCopyBufferInfo2 *)args->pCopyBufferInfo);
5413 } else {
5414 args->pCopyBufferInfo = NULL;
5415 vn_cs_decoder_set_fatal(dec);
5416 }
5417 }
5418
vn_replace_vkCmdCopyBuffer2_args_handle(struct vn_command_vkCmdCopyBuffer2 * args)5419 static inline void vn_replace_vkCmdCopyBuffer2_args_handle(struct vn_command_vkCmdCopyBuffer2 *args)
5420 {
5421 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5422 if (args->pCopyBufferInfo)
5423 vn_replace_VkCopyBufferInfo2_handle((VkCopyBufferInfo2 *)args->pCopyBufferInfo);
5424 }
5425
vn_encode_vkCmdCopyBuffer2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyBuffer2 * args)5426 static inline void vn_encode_vkCmdCopyBuffer2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyBuffer2 *args)
5427 {
5428 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT});
5429
5430 /* skip args->commandBuffer */
5431 /* skip args->pCopyBufferInfo */
5432 }
5433
vn_decode_vkCmdCopyImage2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyImage2 * args)5434 static inline void vn_decode_vkCmdCopyImage2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyImage2 *args)
5435 {
5436 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5437 if (vn_decode_simple_pointer(dec)) {
5438 args->pCopyImageInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCopyImageInfo));
5439 if (!args->pCopyImageInfo) return;
5440 vn_decode_VkCopyImageInfo2_temp(dec, (VkCopyImageInfo2 *)args->pCopyImageInfo);
5441 } else {
5442 args->pCopyImageInfo = NULL;
5443 vn_cs_decoder_set_fatal(dec);
5444 }
5445 }
5446
vn_replace_vkCmdCopyImage2_args_handle(struct vn_command_vkCmdCopyImage2 * args)5447 static inline void vn_replace_vkCmdCopyImage2_args_handle(struct vn_command_vkCmdCopyImage2 *args)
5448 {
5449 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5450 if (args->pCopyImageInfo)
5451 vn_replace_VkCopyImageInfo2_handle((VkCopyImageInfo2 *)args->pCopyImageInfo);
5452 }
5453
vn_encode_vkCmdCopyImage2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyImage2 * args)5454 static inline void vn_encode_vkCmdCopyImage2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyImage2 *args)
5455 {
5456 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyImage2_EXT});
5457
5458 /* skip args->commandBuffer */
5459 /* skip args->pCopyImageInfo */
5460 }
5461
vn_decode_vkCmdBlitImage2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBlitImage2 * args)5462 static inline void vn_decode_vkCmdBlitImage2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBlitImage2 *args)
5463 {
5464 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5465 if (vn_decode_simple_pointer(dec)) {
5466 args->pBlitImageInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBlitImageInfo));
5467 if (!args->pBlitImageInfo) return;
5468 vn_decode_VkBlitImageInfo2_temp(dec, (VkBlitImageInfo2 *)args->pBlitImageInfo);
5469 } else {
5470 args->pBlitImageInfo = NULL;
5471 vn_cs_decoder_set_fatal(dec);
5472 }
5473 }
5474
vn_replace_vkCmdBlitImage2_args_handle(struct vn_command_vkCmdBlitImage2 * args)5475 static inline void vn_replace_vkCmdBlitImage2_args_handle(struct vn_command_vkCmdBlitImage2 *args)
5476 {
5477 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5478 if (args->pBlitImageInfo)
5479 vn_replace_VkBlitImageInfo2_handle((VkBlitImageInfo2 *)args->pBlitImageInfo);
5480 }
5481
vn_encode_vkCmdBlitImage2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBlitImage2 * args)5482 static inline void vn_encode_vkCmdBlitImage2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBlitImage2 *args)
5483 {
5484 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBlitImage2_EXT});
5485
5486 /* skip args->commandBuffer */
5487 /* skip args->pBlitImageInfo */
5488 }
5489
vn_decode_vkCmdCopyBufferToImage2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyBufferToImage2 * args)5490 static inline void vn_decode_vkCmdCopyBufferToImage2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyBufferToImage2 *args)
5491 {
5492 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5493 if (vn_decode_simple_pointer(dec)) {
5494 args->pCopyBufferToImageInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCopyBufferToImageInfo));
5495 if (!args->pCopyBufferToImageInfo) return;
5496 vn_decode_VkCopyBufferToImageInfo2_temp(dec, (VkCopyBufferToImageInfo2 *)args->pCopyBufferToImageInfo);
5497 } else {
5498 args->pCopyBufferToImageInfo = NULL;
5499 vn_cs_decoder_set_fatal(dec);
5500 }
5501 }
5502
vn_replace_vkCmdCopyBufferToImage2_args_handle(struct vn_command_vkCmdCopyBufferToImage2 * args)5503 static inline void vn_replace_vkCmdCopyBufferToImage2_args_handle(struct vn_command_vkCmdCopyBufferToImage2 *args)
5504 {
5505 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5506 if (args->pCopyBufferToImageInfo)
5507 vn_replace_VkCopyBufferToImageInfo2_handle((VkCopyBufferToImageInfo2 *)args->pCopyBufferToImageInfo);
5508 }
5509
vn_encode_vkCmdCopyBufferToImage2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyBufferToImage2 * args)5510 static inline void vn_encode_vkCmdCopyBufferToImage2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyBufferToImage2 *args)
5511 {
5512 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT});
5513
5514 /* skip args->commandBuffer */
5515 /* skip args->pCopyBufferToImageInfo */
5516 }
5517
vn_decode_vkCmdCopyImageToBuffer2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdCopyImageToBuffer2 * args)5518 static inline void vn_decode_vkCmdCopyImageToBuffer2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdCopyImageToBuffer2 *args)
5519 {
5520 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5521 if (vn_decode_simple_pointer(dec)) {
5522 args->pCopyImageToBufferInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCopyImageToBufferInfo));
5523 if (!args->pCopyImageToBufferInfo) return;
5524 vn_decode_VkCopyImageToBufferInfo2_temp(dec, (VkCopyImageToBufferInfo2 *)args->pCopyImageToBufferInfo);
5525 } else {
5526 args->pCopyImageToBufferInfo = NULL;
5527 vn_cs_decoder_set_fatal(dec);
5528 }
5529 }
5530
vn_replace_vkCmdCopyImageToBuffer2_args_handle(struct vn_command_vkCmdCopyImageToBuffer2 * args)5531 static inline void vn_replace_vkCmdCopyImageToBuffer2_args_handle(struct vn_command_vkCmdCopyImageToBuffer2 *args)
5532 {
5533 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5534 if (args->pCopyImageToBufferInfo)
5535 vn_replace_VkCopyImageToBufferInfo2_handle((VkCopyImageToBufferInfo2 *)args->pCopyImageToBufferInfo);
5536 }
5537
vn_encode_vkCmdCopyImageToBuffer2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdCopyImageToBuffer2 * args)5538 static inline void vn_encode_vkCmdCopyImageToBuffer2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdCopyImageToBuffer2 *args)
5539 {
5540 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT});
5541
5542 /* skip args->commandBuffer */
5543 /* skip args->pCopyImageToBufferInfo */
5544 }
5545
vn_decode_vkCmdResolveImage2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdResolveImage2 * args)5546 static inline void vn_decode_vkCmdResolveImage2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResolveImage2 *args)
5547 {
5548 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5549 if (vn_decode_simple_pointer(dec)) {
5550 args->pResolveImageInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pResolveImageInfo));
5551 if (!args->pResolveImageInfo) return;
5552 vn_decode_VkResolveImageInfo2_temp(dec, (VkResolveImageInfo2 *)args->pResolveImageInfo);
5553 } else {
5554 args->pResolveImageInfo = NULL;
5555 vn_cs_decoder_set_fatal(dec);
5556 }
5557 }
5558
vn_replace_vkCmdResolveImage2_args_handle(struct vn_command_vkCmdResolveImage2 * args)5559 static inline void vn_replace_vkCmdResolveImage2_args_handle(struct vn_command_vkCmdResolveImage2 *args)
5560 {
5561 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5562 if (args->pResolveImageInfo)
5563 vn_replace_VkResolveImageInfo2_handle((VkResolveImageInfo2 *)args->pResolveImageInfo);
5564 }
5565
vn_encode_vkCmdResolveImage2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdResolveImage2 * args)5566 static inline void vn_encode_vkCmdResolveImage2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResolveImage2 *args)
5567 {
5568 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResolveImage2_EXT});
5569
5570 /* skip args->commandBuffer */
5571 /* skip args->pResolveImageInfo */
5572 }
5573
vn_decode_vkCmdSetEvent2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdSetEvent2 * args)5574 static inline void vn_decode_vkCmdSetEvent2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdSetEvent2 *args)
5575 {
5576 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5577 vn_decode_VkEvent_lookup(dec, &args->event);
5578 if (vn_decode_simple_pointer(dec)) {
5579 args->pDependencyInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDependencyInfo));
5580 if (!args->pDependencyInfo) return;
5581 vn_decode_VkDependencyInfo_temp(dec, (VkDependencyInfo *)args->pDependencyInfo);
5582 } else {
5583 args->pDependencyInfo = NULL;
5584 vn_cs_decoder_set_fatal(dec);
5585 }
5586 }
5587
vn_replace_vkCmdSetEvent2_args_handle(struct vn_command_vkCmdSetEvent2 * args)5588 static inline void vn_replace_vkCmdSetEvent2_args_handle(struct vn_command_vkCmdSetEvent2 *args)
5589 {
5590 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5591 vn_replace_VkEvent_handle(&args->event);
5592 if (args->pDependencyInfo)
5593 vn_replace_VkDependencyInfo_handle((VkDependencyInfo *)args->pDependencyInfo);
5594 }
5595
vn_encode_vkCmdSetEvent2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdSetEvent2 * args)5596 static inline void vn_encode_vkCmdSetEvent2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdSetEvent2 *args)
5597 {
5598 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdSetEvent2_EXT});
5599
5600 /* skip args->commandBuffer */
5601 /* skip args->event */
5602 /* skip args->pDependencyInfo */
5603 }
5604
vn_decode_vkCmdResetEvent2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdResetEvent2 * args)5605 static inline void vn_decode_vkCmdResetEvent2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdResetEvent2 *args)
5606 {
5607 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5608 vn_decode_VkEvent_lookup(dec, &args->event);
5609 vn_decode_VkFlags64(dec, &args->stageMask);
5610 }
5611
vn_replace_vkCmdResetEvent2_args_handle(struct vn_command_vkCmdResetEvent2 * args)5612 static inline void vn_replace_vkCmdResetEvent2_args_handle(struct vn_command_vkCmdResetEvent2 *args)
5613 {
5614 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5615 vn_replace_VkEvent_handle(&args->event);
5616 /* skip args->stageMask */
5617 }
5618
vn_encode_vkCmdResetEvent2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdResetEvent2 * args)5619 static inline void vn_encode_vkCmdResetEvent2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdResetEvent2 *args)
5620 {
5621 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdResetEvent2_EXT});
5622
5623 /* skip args->commandBuffer */
5624 /* skip args->event */
5625 /* skip args->stageMask */
5626 }
5627
vn_decode_vkCmdWaitEvents2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdWaitEvents2 * args)5628 static inline void vn_decode_vkCmdWaitEvents2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdWaitEvents2 *args)
5629 {
5630 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5631 vn_decode_uint32_t(dec, &args->eventCount);
5632 if (vn_peek_array_size(dec)) {
5633 const uint32_t iter_count = vn_decode_array_size(dec, args->eventCount);
5634 args->pEvents = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pEvents) * iter_count);
5635 if (!args->pEvents) return;
5636 for (uint32_t i = 0; i < iter_count; i++)
5637 vn_decode_VkEvent_lookup(dec, &((VkEvent *)args->pEvents)[i]);
5638 } else {
5639 vn_decode_array_size(dec, args->eventCount);
5640 args->pEvents = NULL;
5641 }
5642 if (vn_peek_array_size(dec)) {
5643 const uint32_t iter_count = vn_decode_array_size(dec, args->eventCount);
5644 args->pDependencyInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDependencyInfos) * iter_count);
5645 if (!args->pDependencyInfos) return;
5646 for (uint32_t i = 0; i < iter_count; i++)
5647 vn_decode_VkDependencyInfo_temp(dec, &((VkDependencyInfo *)args->pDependencyInfos)[i]);
5648 } else {
5649 vn_decode_array_size(dec, args->eventCount);
5650 args->pDependencyInfos = NULL;
5651 }
5652 }
5653
vn_replace_vkCmdWaitEvents2_args_handle(struct vn_command_vkCmdWaitEvents2 * args)5654 static inline void vn_replace_vkCmdWaitEvents2_args_handle(struct vn_command_vkCmdWaitEvents2 *args)
5655 {
5656 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5657 /* skip args->eventCount */
5658 if (args->pEvents) {
5659 for (uint32_t i = 0; i < args->eventCount; i++)
5660 vn_replace_VkEvent_handle(&((VkEvent *)args->pEvents)[i]);
5661 }
5662 if (args->pDependencyInfos) {
5663 for (uint32_t i = 0; i < args->eventCount; i++)
5664 vn_replace_VkDependencyInfo_handle(&((VkDependencyInfo *)args->pDependencyInfos)[i]);
5665 }
5666 }
5667
vn_encode_vkCmdWaitEvents2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdWaitEvents2 * args)5668 static inline void vn_encode_vkCmdWaitEvents2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdWaitEvents2 *args)
5669 {
5670 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT});
5671
5672 /* skip args->commandBuffer */
5673 /* skip args->eventCount */
5674 /* skip args->pEvents */
5675 /* skip args->pDependencyInfos */
5676 }
5677
vn_decode_vkCmdPipelineBarrier2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdPipelineBarrier2 * args)5678 static inline void vn_decode_vkCmdPipelineBarrier2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdPipelineBarrier2 *args)
5679 {
5680 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5681 if (vn_decode_simple_pointer(dec)) {
5682 args->pDependencyInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pDependencyInfo));
5683 if (!args->pDependencyInfo) return;
5684 vn_decode_VkDependencyInfo_temp(dec, (VkDependencyInfo *)args->pDependencyInfo);
5685 } else {
5686 args->pDependencyInfo = NULL;
5687 vn_cs_decoder_set_fatal(dec);
5688 }
5689 }
5690
vn_replace_vkCmdPipelineBarrier2_args_handle(struct vn_command_vkCmdPipelineBarrier2 * args)5691 static inline void vn_replace_vkCmdPipelineBarrier2_args_handle(struct vn_command_vkCmdPipelineBarrier2 *args)
5692 {
5693 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5694 if (args->pDependencyInfo)
5695 vn_replace_VkDependencyInfo_handle((VkDependencyInfo *)args->pDependencyInfo);
5696 }
5697
vn_encode_vkCmdPipelineBarrier2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdPipelineBarrier2 * args)5698 static inline void vn_encode_vkCmdPipelineBarrier2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdPipelineBarrier2 *args)
5699 {
5700 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT});
5701
5702 /* skip args->commandBuffer */
5703 /* skip args->pDependencyInfo */
5704 }
5705
vn_decode_vkCmdWriteTimestamp2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdWriteTimestamp2 * args)5706 static inline void vn_decode_vkCmdWriteTimestamp2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdWriteTimestamp2 *args)
5707 {
5708 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5709 vn_decode_VkFlags64(dec, &args->stage);
5710 vn_decode_VkQueryPool_lookup(dec, &args->queryPool);
5711 vn_decode_uint32_t(dec, &args->query);
5712 }
5713
vn_replace_vkCmdWriteTimestamp2_args_handle(struct vn_command_vkCmdWriteTimestamp2 * args)5714 static inline void vn_replace_vkCmdWriteTimestamp2_args_handle(struct vn_command_vkCmdWriteTimestamp2 *args)
5715 {
5716 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5717 /* skip args->stage */
5718 vn_replace_VkQueryPool_handle(&args->queryPool);
5719 /* skip args->query */
5720 }
5721
vn_encode_vkCmdWriteTimestamp2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdWriteTimestamp2 * args)5722 static inline void vn_encode_vkCmdWriteTimestamp2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdWriteTimestamp2 *args)
5723 {
5724 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT});
5725
5726 /* skip args->commandBuffer */
5727 /* skip args->stage */
5728 /* skip args->queryPool */
5729 /* skip args->query */
5730 }
5731
vn_decode_vkCmdBeginRendering_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdBeginRendering * args)5732 static inline void vn_decode_vkCmdBeginRendering_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdBeginRendering *args)
5733 {
5734 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5735 if (vn_decode_simple_pointer(dec)) {
5736 args->pRenderingInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pRenderingInfo));
5737 if (!args->pRenderingInfo) return;
5738 vn_decode_VkRenderingInfo_temp(dec, (VkRenderingInfo *)args->pRenderingInfo);
5739 } else {
5740 args->pRenderingInfo = NULL;
5741 vn_cs_decoder_set_fatal(dec);
5742 }
5743 }
5744
vn_replace_vkCmdBeginRendering_args_handle(struct vn_command_vkCmdBeginRendering * args)5745 static inline void vn_replace_vkCmdBeginRendering_args_handle(struct vn_command_vkCmdBeginRendering *args)
5746 {
5747 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5748 if (args->pRenderingInfo)
5749 vn_replace_VkRenderingInfo_handle((VkRenderingInfo *)args->pRenderingInfo);
5750 }
5751
vn_encode_vkCmdBeginRendering_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdBeginRendering * args)5752 static inline void vn_encode_vkCmdBeginRendering_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdBeginRendering *args)
5753 {
5754 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdBeginRendering_EXT});
5755
5756 /* skip args->commandBuffer */
5757 /* skip args->pRenderingInfo */
5758 }
5759
vn_decode_vkCmdEndRendering_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCmdEndRendering * args)5760 static inline void vn_decode_vkCmdEndRendering_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCmdEndRendering *args)
5761 {
5762 vn_decode_VkCommandBuffer_lookup(dec, &args->commandBuffer);
5763 }
5764
vn_replace_vkCmdEndRendering_args_handle(struct vn_command_vkCmdEndRendering * args)5765 static inline void vn_replace_vkCmdEndRendering_args_handle(struct vn_command_vkCmdEndRendering *args)
5766 {
5767 vn_replace_VkCommandBuffer_handle(&args->commandBuffer);
5768 }
5769
vn_encode_vkCmdEndRendering_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCmdEndRendering * args)5770 static inline void vn_encode_vkCmdEndRendering_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCmdEndRendering *args)
5771 {
5772 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCmdEndRendering_EXT});
5773
5774 /* skip args->commandBuffer */
5775 }
5776
vn_dispatch_vkAllocateCommandBuffers(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5777 static inline void vn_dispatch_vkAllocateCommandBuffers(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5778 {
5779 struct vn_command_vkAllocateCommandBuffers args;
5780
5781 if (!ctx->dispatch_vkAllocateCommandBuffers) {
5782 vn_cs_decoder_set_fatal(ctx->decoder);
5783 return;
5784 }
5785
5786 vn_decode_vkAllocateCommandBuffers_args_temp(ctx->decoder, &args);
5787 if (!args.device) {
5788 vn_cs_decoder_set_fatal(ctx->decoder);
5789 return;
5790 }
5791
5792 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5793 ctx->dispatch_vkAllocateCommandBuffers(ctx, &args);
5794
5795 #ifdef DEBUG
5796 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
5797 vn_dispatch_debug_log(ctx, "vkAllocateCommandBuffers returned %d", args.ret);
5798 #endif
5799
5800 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5801 vn_encode_vkAllocateCommandBuffers_reply(ctx->encoder, &args);
5802
5803 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5804 }
5805
vn_dispatch_vkFreeCommandBuffers(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5806 static inline void vn_dispatch_vkFreeCommandBuffers(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5807 {
5808 struct vn_command_vkFreeCommandBuffers args;
5809
5810 if (!ctx->dispatch_vkFreeCommandBuffers) {
5811 vn_cs_decoder_set_fatal(ctx->decoder);
5812 return;
5813 }
5814
5815 vn_decode_vkFreeCommandBuffers_args_temp(ctx->decoder, &args);
5816 if (!args.device) {
5817 vn_cs_decoder_set_fatal(ctx->decoder);
5818 return;
5819 }
5820
5821 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5822 ctx->dispatch_vkFreeCommandBuffers(ctx, &args);
5823
5824
5825 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5826 vn_encode_vkFreeCommandBuffers_reply(ctx->encoder, &args);
5827
5828 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5829 }
5830
vn_dispatch_vkBeginCommandBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5831 static inline void vn_dispatch_vkBeginCommandBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5832 {
5833 struct vn_command_vkBeginCommandBuffer args;
5834
5835 if (!ctx->dispatch_vkBeginCommandBuffer) {
5836 vn_cs_decoder_set_fatal(ctx->decoder);
5837 return;
5838 }
5839
5840 vn_decode_vkBeginCommandBuffer_args_temp(ctx->decoder, &args);
5841 if (!args.commandBuffer) {
5842 vn_cs_decoder_set_fatal(ctx->decoder);
5843 return;
5844 }
5845
5846 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5847 ctx->dispatch_vkBeginCommandBuffer(ctx, &args);
5848
5849 #ifdef DEBUG
5850 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
5851 vn_dispatch_debug_log(ctx, "vkBeginCommandBuffer returned %d", args.ret);
5852 #endif
5853
5854 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5855 vn_encode_vkBeginCommandBuffer_reply(ctx->encoder, &args);
5856
5857 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5858 }
5859
vn_dispatch_vkEndCommandBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5860 static inline void vn_dispatch_vkEndCommandBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5861 {
5862 struct vn_command_vkEndCommandBuffer args;
5863
5864 if (!ctx->dispatch_vkEndCommandBuffer) {
5865 vn_cs_decoder_set_fatal(ctx->decoder);
5866 return;
5867 }
5868
5869 vn_decode_vkEndCommandBuffer_args_temp(ctx->decoder, &args);
5870 if (!args.commandBuffer) {
5871 vn_cs_decoder_set_fatal(ctx->decoder);
5872 return;
5873 }
5874
5875 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5876 ctx->dispatch_vkEndCommandBuffer(ctx, &args);
5877
5878 #ifdef DEBUG
5879 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
5880 vn_dispatch_debug_log(ctx, "vkEndCommandBuffer returned %d", args.ret);
5881 #endif
5882
5883 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5884 vn_encode_vkEndCommandBuffer_reply(ctx->encoder, &args);
5885
5886 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5887 }
5888
vn_dispatch_vkResetCommandBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5889 static inline void vn_dispatch_vkResetCommandBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5890 {
5891 struct vn_command_vkResetCommandBuffer args;
5892
5893 if (!ctx->dispatch_vkResetCommandBuffer) {
5894 vn_cs_decoder_set_fatal(ctx->decoder);
5895 return;
5896 }
5897
5898 vn_decode_vkResetCommandBuffer_args_temp(ctx->decoder, &args);
5899 if (!args.commandBuffer) {
5900 vn_cs_decoder_set_fatal(ctx->decoder);
5901 return;
5902 }
5903
5904 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5905 ctx->dispatch_vkResetCommandBuffer(ctx, &args);
5906
5907 #ifdef DEBUG
5908 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
5909 vn_dispatch_debug_log(ctx, "vkResetCommandBuffer returned %d", args.ret);
5910 #endif
5911
5912 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5913 vn_encode_vkResetCommandBuffer_reply(ctx->encoder, &args);
5914
5915 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5916 }
5917
vn_dispatch_vkCmdBindPipeline(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5918 static inline void vn_dispatch_vkCmdBindPipeline(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5919 {
5920 struct vn_command_vkCmdBindPipeline args;
5921
5922 if (!ctx->dispatch_vkCmdBindPipeline) {
5923 vn_cs_decoder_set_fatal(ctx->decoder);
5924 return;
5925 }
5926
5927 vn_decode_vkCmdBindPipeline_args_temp(ctx->decoder, &args);
5928 if (!args.commandBuffer) {
5929 vn_cs_decoder_set_fatal(ctx->decoder);
5930 return;
5931 }
5932
5933 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5934 ctx->dispatch_vkCmdBindPipeline(ctx, &args);
5935
5936
5937 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5938 vn_encode_vkCmdBindPipeline_reply(ctx->encoder, &args);
5939
5940 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5941 }
5942
vn_dispatch_vkCmdSetViewport(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5943 static inline void vn_dispatch_vkCmdSetViewport(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5944 {
5945 struct vn_command_vkCmdSetViewport args;
5946
5947 if (!ctx->dispatch_vkCmdSetViewport) {
5948 vn_cs_decoder_set_fatal(ctx->decoder);
5949 return;
5950 }
5951
5952 vn_decode_vkCmdSetViewport_args_temp(ctx->decoder, &args);
5953 if (!args.commandBuffer) {
5954 vn_cs_decoder_set_fatal(ctx->decoder);
5955 return;
5956 }
5957
5958 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5959 ctx->dispatch_vkCmdSetViewport(ctx, &args);
5960
5961
5962 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5963 vn_encode_vkCmdSetViewport_reply(ctx->encoder, &args);
5964
5965 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5966 }
5967
vn_dispatch_vkCmdSetScissor(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5968 static inline void vn_dispatch_vkCmdSetScissor(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5969 {
5970 struct vn_command_vkCmdSetScissor args;
5971
5972 if (!ctx->dispatch_vkCmdSetScissor) {
5973 vn_cs_decoder_set_fatal(ctx->decoder);
5974 return;
5975 }
5976
5977 vn_decode_vkCmdSetScissor_args_temp(ctx->decoder, &args);
5978 if (!args.commandBuffer) {
5979 vn_cs_decoder_set_fatal(ctx->decoder);
5980 return;
5981 }
5982
5983 if (!vn_cs_decoder_get_fatal(ctx->decoder))
5984 ctx->dispatch_vkCmdSetScissor(ctx, &args);
5985
5986
5987 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
5988 vn_encode_vkCmdSetScissor_reply(ctx->encoder, &args);
5989
5990 vn_cs_decoder_reset_temp_pool(ctx->decoder);
5991 }
5992
vn_dispatch_vkCmdSetLineWidth(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)5993 static inline void vn_dispatch_vkCmdSetLineWidth(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
5994 {
5995 struct vn_command_vkCmdSetLineWidth args;
5996
5997 if (!ctx->dispatch_vkCmdSetLineWidth) {
5998 vn_cs_decoder_set_fatal(ctx->decoder);
5999 return;
6000 }
6001
6002 vn_decode_vkCmdSetLineWidth_args_temp(ctx->decoder, &args);
6003 if (!args.commandBuffer) {
6004 vn_cs_decoder_set_fatal(ctx->decoder);
6005 return;
6006 }
6007
6008 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6009 ctx->dispatch_vkCmdSetLineWidth(ctx, &args);
6010
6011
6012 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6013 vn_encode_vkCmdSetLineWidth_reply(ctx->encoder, &args);
6014
6015 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6016 }
6017
vn_dispatch_vkCmdSetDepthBias(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6018 static inline void vn_dispatch_vkCmdSetDepthBias(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6019 {
6020 struct vn_command_vkCmdSetDepthBias args;
6021
6022 if (!ctx->dispatch_vkCmdSetDepthBias) {
6023 vn_cs_decoder_set_fatal(ctx->decoder);
6024 return;
6025 }
6026
6027 vn_decode_vkCmdSetDepthBias_args_temp(ctx->decoder, &args);
6028 if (!args.commandBuffer) {
6029 vn_cs_decoder_set_fatal(ctx->decoder);
6030 return;
6031 }
6032
6033 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6034 ctx->dispatch_vkCmdSetDepthBias(ctx, &args);
6035
6036
6037 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6038 vn_encode_vkCmdSetDepthBias_reply(ctx->encoder, &args);
6039
6040 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6041 }
6042
vn_dispatch_vkCmdSetBlendConstants(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6043 static inline void vn_dispatch_vkCmdSetBlendConstants(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6044 {
6045 struct vn_command_vkCmdSetBlendConstants args;
6046
6047 if (!ctx->dispatch_vkCmdSetBlendConstants) {
6048 vn_cs_decoder_set_fatal(ctx->decoder);
6049 return;
6050 }
6051
6052 vn_decode_vkCmdSetBlendConstants_args_temp(ctx->decoder, &args);
6053 if (!args.commandBuffer) {
6054 vn_cs_decoder_set_fatal(ctx->decoder);
6055 return;
6056 }
6057
6058 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6059 ctx->dispatch_vkCmdSetBlendConstants(ctx, &args);
6060
6061
6062 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6063 vn_encode_vkCmdSetBlendConstants_reply(ctx->encoder, &args);
6064
6065 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6066 }
6067
vn_dispatch_vkCmdSetDepthBounds(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6068 static inline void vn_dispatch_vkCmdSetDepthBounds(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6069 {
6070 struct vn_command_vkCmdSetDepthBounds args;
6071
6072 if (!ctx->dispatch_vkCmdSetDepthBounds) {
6073 vn_cs_decoder_set_fatal(ctx->decoder);
6074 return;
6075 }
6076
6077 vn_decode_vkCmdSetDepthBounds_args_temp(ctx->decoder, &args);
6078 if (!args.commandBuffer) {
6079 vn_cs_decoder_set_fatal(ctx->decoder);
6080 return;
6081 }
6082
6083 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6084 ctx->dispatch_vkCmdSetDepthBounds(ctx, &args);
6085
6086
6087 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6088 vn_encode_vkCmdSetDepthBounds_reply(ctx->encoder, &args);
6089
6090 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6091 }
6092
vn_dispatch_vkCmdSetStencilCompareMask(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6093 static inline void vn_dispatch_vkCmdSetStencilCompareMask(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6094 {
6095 struct vn_command_vkCmdSetStencilCompareMask args;
6096
6097 if (!ctx->dispatch_vkCmdSetStencilCompareMask) {
6098 vn_cs_decoder_set_fatal(ctx->decoder);
6099 return;
6100 }
6101
6102 vn_decode_vkCmdSetStencilCompareMask_args_temp(ctx->decoder, &args);
6103 if (!args.commandBuffer) {
6104 vn_cs_decoder_set_fatal(ctx->decoder);
6105 return;
6106 }
6107
6108 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6109 ctx->dispatch_vkCmdSetStencilCompareMask(ctx, &args);
6110
6111
6112 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6113 vn_encode_vkCmdSetStencilCompareMask_reply(ctx->encoder, &args);
6114
6115 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6116 }
6117
vn_dispatch_vkCmdSetStencilWriteMask(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6118 static inline void vn_dispatch_vkCmdSetStencilWriteMask(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6119 {
6120 struct vn_command_vkCmdSetStencilWriteMask args;
6121
6122 if (!ctx->dispatch_vkCmdSetStencilWriteMask) {
6123 vn_cs_decoder_set_fatal(ctx->decoder);
6124 return;
6125 }
6126
6127 vn_decode_vkCmdSetStencilWriteMask_args_temp(ctx->decoder, &args);
6128 if (!args.commandBuffer) {
6129 vn_cs_decoder_set_fatal(ctx->decoder);
6130 return;
6131 }
6132
6133 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6134 ctx->dispatch_vkCmdSetStencilWriteMask(ctx, &args);
6135
6136
6137 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6138 vn_encode_vkCmdSetStencilWriteMask_reply(ctx->encoder, &args);
6139
6140 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6141 }
6142
vn_dispatch_vkCmdSetStencilReference(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6143 static inline void vn_dispatch_vkCmdSetStencilReference(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6144 {
6145 struct vn_command_vkCmdSetStencilReference args;
6146
6147 if (!ctx->dispatch_vkCmdSetStencilReference) {
6148 vn_cs_decoder_set_fatal(ctx->decoder);
6149 return;
6150 }
6151
6152 vn_decode_vkCmdSetStencilReference_args_temp(ctx->decoder, &args);
6153 if (!args.commandBuffer) {
6154 vn_cs_decoder_set_fatal(ctx->decoder);
6155 return;
6156 }
6157
6158 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6159 ctx->dispatch_vkCmdSetStencilReference(ctx, &args);
6160
6161
6162 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6163 vn_encode_vkCmdSetStencilReference_reply(ctx->encoder, &args);
6164
6165 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6166 }
6167
vn_dispatch_vkCmdBindDescriptorSets(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6168 static inline void vn_dispatch_vkCmdBindDescriptorSets(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6169 {
6170 struct vn_command_vkCmdBindDescriptorSets args;
6171
6172 if (!ctx->dispatch_vkCmdBindDescriptorSets) {
6173 vn_cs_decoder_set_fatal(ctx->decoder);
6174 return;
6175 }
6176
6177 vn_decode_vkCmdBindDescriptorSets_args_temp(ctx->decoder, &args);
6178 if (!args.commandBuffer) {
6179 vn_cs_decoder_set_fatal(ctx->decoder);
6180 return;
6181 }
6182
6183 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6184 ctx->dispatch_vkCmdBindDescriptorSets(ctx, &args);
6185
6186
6187 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6188 vn_encode_vkCmdBindDescriptorSets_reply(ctx->encoder, &args);
6189
6190 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6191 }
6192
vn_dispatch_vkCmdBindIndexBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6193 static inline void vn_dispatch_vkCmdBindIndexBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6194 {
6195 struct vn_command_vkCmdBindIndexBuffer args;
6196
6197 if (!ctx->dispatch_vkCmdBindIndexBuffer) {
6198 vn_cs_decoder_set_fatal(ctx->decoder);
6199 return;
6200 }
6201
6202 vn_decode_vkCmdBindIndexBuffer_args_temp(ctx->decoder, &args);
6203 if (!args.commandBuffer) {
6204 vn_cs_decoder_set_fatal(ctx->decoder);
6205 return;
6206 }
6207
6208 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6209 ctx->dispatch_vkCmdBindIndexBuffer(ctx, &args);
6210
6211
6212 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6213 vn_encode_vkCmdBindIndexBuffer_reply(ctx->encoder, &args);
6214
6215 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6216 }
6217
vn_dispatch_vkCmdBindVertexBuffers(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6218 static inline void vn_dispatch_vkCmdBindVertexBuffers(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6219 {
6220 struct vn_command_vkCmdBindVertexBuffers args;
6221
6222 if (!ctx->dispatch_vkCmdBindVertexBuffers) {
6223 vn_cs_decoder_set_fatal(ctx->decoder);
6224 return;
6225 }
6226
6227 vn_decode_vkCmdBindVertexBuffers_args_temp(ctx->decoder, &args);
6228 if (!args.commandBuffer) {
6229 vn_cs_decoder_set_fatal(ctx->decoder);
6230 return;
6231 }
6232
6233 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6234 ctx->dispatch_vkCmdBindVertexBuffers(ctx, &args);
6235
6236
6237 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6238 vn_encode_vkCmdBindVertexBuffers_reply(ctx->encoder, &args);
6239
6240 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6241 }
6242
vn_dispatch_vkCmdDraw(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6243 static inline void vn_dispatch_vkCmdDraw(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6244 {
6245 struct vn_command_vkCmdDraw args;
6246
6247 if (!ctx->dispatch_vkCmdDraw) {
6248 vn_cs_decoder_set_fatal(ctx->decoder);
6249 return;
6250 }
6251
6252 vn_decode_vkCmdDraw_args_temp(ctx->decoder, &args);
6253 if (!args.commandBuffer) {
6254 vn_cs_decoder_set_fatal(ctx->decoder);
6255 return;
6256 }
6257
6258 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6259 ctx->dispatch_vkCmdDraw(ctx, &args);
6260
6261
6262 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6263 vn_encode_vkCmdDraw_reply(ctx->encoder, &args);
6264
6265 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6266 }
6267
vn_dispatch_vkCmdDrawIndexed(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6268 static inline void vn_dispatch_vkCmdDrawIndexed(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6269 {
6270 struct vn_command_vkCmdDrawIndexed args;
6271
6272 if (!ctx->dispatch_vkCmdDrawIndexed) {
6273 vn_cs_decoder_set_fatal(ctx->decoder);
6274 return;
6275 }
6276
6277 vn_decode_vkCmdDrawIndexed_args_temp(ctx->decoder, &args);
6278 if (!args.commandBuffer) {
6279 vn_cs_decoder_set_fatal(ctx->decoder);
6280 return;
6281 }
6282
6283 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6284 ctx->dispatch_vkCmdDrawIndexed(ctx, &args);
6285
6286
6287 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6288 vn_encode_vkCmdDrawIndexed_reply(ctx->encoder, &args);
6289
6290 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6291 }
6292
vn_dispatch_vkCmdDrawMultiEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6293 static inline void vn_dispatch_vkCmdDrawMultiEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6294 {
6295 struct vn_command_vkCmdDrawMultiEXT args;
6296
6297 if (!ctx->dispatch_vkCmdDrawMultiEXT) {
6298 vn_cs_decoder_set_fatal(ctx->decoder);
6299 return;
6300 }
6301
6302 vn_decode_vkCmdDrawMultiEXT_args_temp(ctx->decoder, &args);
6303 if (!args.commandBuffer) {
6304 vn_cs_decoder_set_fatal(ctx->decoder);
6305 return;
6306 }
6307
6308 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6309 ctx->dispatch_vkCmdDrawMultiEXT(ctx, &args);
6310
6311
6312 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6313 vn_encode_vkCmdDrawMultiEXT_reply(ctx->encoder, &args);
6314
6315 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6316 }
6317
vn_dispatch_vkCmdDrawMultiIndexedEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6318 static inline void vn_dispatch_vkCmdDrawMultiIndexedEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6319 {
6320 struct vn_command_vkCmdDrawMultiIndexedEXT args;
6321
6322 if (!ctx->dispatch_vkCmdDrawMultiIndexedEXT) {
6323 vn_cs_decoder_set_fatal(ctx->decoder);
6324 return;
6325 }
6326
6327 vn_decode_vkCmdDrawMultiIndexedEXT_args_temp(ctx->decoder, &args);
6328 if (!args.commandBuffer) {
6329 vn_cs_decoder_set_fatal(ctx->decoder);
6330 return;
6331 }
6332
6333 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6334 ctx->dispatch_vkCmdDrawMultiIndexedEXT(ctx, &args);
6335
6336
6337 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6338 vn_encode_vkCmdDrawMultiIndexedEXT_reply(ctx->encoder, &args);
6339
6340 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6341 }
6342
vn_dispatch_vkCmdDrawIndirect(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6343 static inline void vn_dispatch_vkCmdDrawIndirect(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6344 {
6345 struct vn_command_vkCmdDrawIndirect args;
6346
6347 if (!ctx->dispatch_vkCmdDrawIndirect) {
6348 vn_cs_decoder_set_fatal(ctx->decoder);
6349 return;
6350 }
6351
6352 vn_decode_vkCmdDrawIndirect_args_temp(ctx->decoder, &args);
6353 if (!args.commandBuffer) {
6354 vn_cs_decoder_set_fatal(ctx->decoder);
6355 return;
6356 }
6357
6358 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6359 ctx->dispatch_vkCmdDrawIndirect(ctx, &args);
6360
6361
6362 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6363 vn_encode_vkCmdDrawIndirect_reply(ctx->encoder, &args);
6364
6365 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6366 }
6367
vn_dispatch_vkCmdDrawIndexedIndirect(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6368 static inline void vn_dispatch_vkCmdDrawIndexedIndirect(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6369 {
6370 struct vn_command_vkCmdDrawIndexedIndirect args;
6371
6372 if (!ctx->dispatch_vkCmdDrawIndexedIndirect) {
6373 vn_cs_decoder_set_fatal(ctx->decoder);
6374 return;
6375 }
6376
6377 vn_decode_vkCmdDrawIndexedIndirect_args_temp(ctx->decoder, &args);
6378 if (!args.commandBuffer) {
6379 vn_cs_decoder_set_fatal(ctx->decoder);
6380 return;
6381 }
6382
6383 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6384 ctx->dispatch_vkCmdDrawIndexedIndirect(ctx, &args);
6385
6386
6387 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6388 vn_encode_vkCmdDrawIndexedIndirect_reply(ctx->encoder, &args);
6389
6390 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6391 }
6392
vn_dispatch_vkCmdDispatch(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6393 static inline void vn_dispatch_vkCmdDispatch(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6394 {
6395 struct vn_command_vkCmdDispatch args;
6396
6397 if (!ctx->dispatch_vkCmdDispatch) {
6398 vn_cs_decoder_set_fatal(ctx->decoder);
6399 return;
6400 }
6401
6402 vn_decode_vkCmdDispatch_args_temp(ctx->decoder, &args);
6403 if (!args.commandBuffer) {
6404 vn_cs_decoder_set_fatal(ctx->decoder);
6405 return;
6406 }
6407
6408 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6409 ctx->dispatch_vkCmdDispatch(ctx, &args);
6410
6411
6412 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6413 vn_encode_vkCmdDispatch_reply(ctx->encoder, &args);
6414
6415 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6416 }
6417
vn_dispatch_vkCmdDispatchIndirect(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6418 static inline void vn_dispatch_vkCmdDispatchIndirect(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6419 {
6420 struct vn_command_vkCmdDispatchIndirect args;
6421
6422 if (!ctx->dispatch_vkCmdDispatchIndirect) {
6423 vn_cs_decoder_set_fatal(ctx->decoder);
6424 return;
6425 }
6426
6427 vn_decode_vkCmdDispatchIndirect_args_temp(ctx->decoder, &args);
6428 if (!args.commandBuffer) {
6429 vn_cs_decoder_set_fatal(ctx->decoder);
6430 return;
6431 }
6432
6433 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6434 ctx->dispatch_vkCmdDispatchIndirect(ctx, &args);
6435
6436
6437 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6438 vn_encode_vkCmdDispatchIndirect_reply(ctx->encoder, &args);
6439
6440 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6441 }
6442
vn_dispatch_vkCmdCopyBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6443 static inline void vn_dispatch_vkCmdCopyBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6444 {
6445 struct vn_command_vkCmdCopyBuffer args;
6446
6447 if (!ctx->dispatch_vkCmdCopyBuffer) {
6448 vn_cs_decoder_set_fatal(ctx->decoder);
6449 return;
6450 }
6451
6452 vn_decode_vkCmdCopyBuffer_args_temp(ctx->decoder, &args);
6453 if (!args.commandBuffer) {
6454 vn_cs_decoder_set_fatal(ctx->decoder);
6455 return;
6456 }
6457
6458 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6459 ctx->dispatch_vkCmdCopyBuffer(ctx, &args);
6460
6461
6462 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6463 vn_encode_vkCmdCopyBuffer_reply(ctx->encoder, &args);
6464
6465 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6466 }
6467
vn_dispatch_vkCmdCopyImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6468 static inline void vn_dispatch_vkCmdCopyImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6469 {
6470 struct vn_command_vkCmdCopyImage args;
6471
6472 if (!ctx->dispatch_vkCmdCopyImage) {
6473 vn_cs_decoder_set_fatal(ctx->decoder);
6474 return;
6475 }
6476
6477 vn_decode_vkCmdCopyImage_args_temp(ctx->decoder, &args);
6478 if (!args.commandBuffer) {
6479 vn_cs_decoder_set_fatal(ctx->decoder);
6480 return;
6481 }
6482
6483 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6484 ctx->dispatch_vkCmdCopyImage(ctx, &args);
6485
6486
6487 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6488 vn_encode_vkCmdCopyImage_reply(ctx->encoder, &args);
6489
6490 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6491 }
6492
vn_dispatch_vkCmdBlitImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6493 static inline void vn_dispatch_vkCmdBlitImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6494 {
6495 struct vn_command_vkCmdBlitImage args;
6496
6497 if (!ctx->dispatch_vkCmdBlitImage) {
6498 vn_cs_decoder_set_fatal(ctx->decoder);
6499 return;
6500 }
6501
6502 vn_decode_vkCmdBlitImage_args_temp(ctx->decoder, &args);
6503 if (!args.commandBuffer) {
6504 vn_cs_decoder_set_fatal(ctx->decoder);
6505 return;
6506 }
6507
6508 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6509 ctx->dispatch_vkCmdBlitImage(ctx, &args);
6510
6511
6512 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6513 vn_encode_vkCmdBlitImage_reply(ctx->encoder, &args);
6514
6515 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6516 }
6517
vn_dispatch_vkCmdCopyBufferToImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6518 static inline void vn_dispatch_vkCmdCopyBufferToImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6519 {
6520 struct vn_command_vkCmdCopyBufferToImage args;
6521
6522 if (!ctx->dispatch_vkCmdCopyBufferToImage) {
6523 vn_cs_decoder_set_fatal(ctx->decoder);
6524 return;
6525 }
6526
6527 vn_decode_vkCmdCopyBufferToImage_args_temp(ctx->decoder, &args);
6528 if (!args.commandBuffer) {
6529 vn_cs_decoder_set_fatal(ctx->decoder);
6530 return;
6531 }
6532
6533 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6534 ctx->dispatch_vkCmdCopyBufferToImage(ctx, &args);
6535
6536
6537 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6538 vn_encode_vkCmdCopyBufferToImage_reply(ctx->encoder, &args);
6539
6540 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6541 }
6542
vn_dispatch_vkCmdCopyImageToBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6543 static inline void vn_dispatch_vkCmdCopyImageToBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6544 {
6545 struct vn_command_vkCmdCopyImageToBuffer args;
6546
6547 if (!ctx->dispatch_vkCmdCopyImageToBuffer) {
6548 vn_cs_decoder_set_fatal(ctx->decoder);
6549 return;
6550 }
6551
6552 vn_decode_vkCmdCopyImageToBuffer_args_temp(ctx->decoder, &args);
6553 if (!args.commandBuffer) {
6554 vn_cs_decoder_set_fatal(ctx->decoder);
6555 return;
6556 }
6557
6558 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6559 ctx->dispatch_vkCmdCopyImageToBuffer(ctx, &args);
6560
6561
6562 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6563 vn_encode_vkCmdCopyImageToBuffer_reply(ctx->encoder, &args);
6564
6565 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6566 }
6567
vn_dispatch_vkCmdUpdateBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6568 static inline void vn_dispatch_vkCmdUpdateBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6569 {
6570 struct vn_command_vkCmdUpdateBuffer args;
6571
6572 if (!ctx->dispatch_vkCmdUpdateBuffer) {
6573 vn_cs_decoder_set_fatal(ctx->decoder);
6574 return;
6575 }
6576
6577 vn_decode_vkCmdUpdateBuffer_args_temp(ctx->decoder, &args);
6578 if (!args.commandBuffer) {
6579 vn_cs_decoder_set_fatal(ctx->decoder);
6580 return;
6581 }
6582
6583 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6584 ctx->dispatch_vkCmdUpdateBuffer(ctx, &args);
6585
6586
6587 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6588 vn_encode_vkCmdUpdateBuffer_reply(ctx->encoder, &args);
6589
6590 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6591 }
6592
vn_dispatch_vkCmdFillBuffer(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6593 static inline void vn_dispatch_vkCmdFillBuffer(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6594 {
6595 struct vn_command_vkCmdFillBuffer args;
6596
6597 if (!ctx->dispatch_vkCmdFillBuffer) {
6598 vn_cs_decoder_set_fatal(ctx->decoder);
6599 return;
6600 }
6601
6602 vn_decode_vkCmdFillBuffer_args_temp(ctx->decoder, &args);
6603 if (!args.commandBuffer) {
6604 vn_cs_decoder_set_fatal(ctx->decoder);
6605 return;
6606 }
6607
6608 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6609 ctx->dispatch_vkCmdFillBuffer(ctx, &args);
6610
6611
6612 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6613 vn_encode_vkCmdFillBuffer_reply(ctx->encoder, &args);
6614
6615 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6616 }
6617
vn_dispatch_vkCmdClearColorImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6618 static inline void vn_dispatch_vkCmdClearColorImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6619 {
6620 struct vn_command_vkCmdClearColorImage args;
6621
6622 if (!ctx->dispatch_vkCmdClearColorImage) {
6623 vn_cs_decoder_set_fatal(ctx->decoder);
6624 return;
6625 }
6626
6627 vn_decode_vkCmdClearColorImage_args_temp(ctx->decoder, &args);
6628 if (!args.commandBuffer) {
6629 vn_cs_decoder_set_fatal(ctx->decoder);
6630 return;
6631 }
6632
6633 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6634 ctx->dispatch_vkCmdClearColorImage(ctx, &args);
6635
6636
6637 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6638 vn_encode_vkCmdClearColorImage_reply(ctx->encoder, &args);
6639
6640 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6641 }
6642
vn_dispatch_vkCmdClearDepthStencilImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6643 static inline void vn_dispatch_vkCmdClearDepthStencilImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6644 {
6645 struct vn_command_vkCmdClearDepthStencilImage args;
6646
6647 if (!ctx->dispatch_vkCmdClearDepthStencilImage) {
6648 vn_cs_decoder_set_fatal(ctx->decoder);
6649 return;
6650 }
6651
6652 vn_decode_vkCmdClearDepthStencilImage_args_temp(ctx->decoder, &args);
6653 if (!args.commandBuffer) {
6654 vn_cs_decoder_set_fatal(ctx->decoder);
6655 return;
6656 }
6657
6658 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6659 ctx->dispatch_vkCmdClearDepthStencilImage(ctx, &args);
6660
6661
6662 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6663 vn_encode_vkCmdClearDepthStencilImage_reply(ctx->encoder, &args);
6664
6665 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6666 }
6667
vn_dispatch_vkCmdClearAttachments(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6668 static inline void vn_dispatch_vkCmdClearAttachments(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6669 {
6670 struct vn_command_vkCmdClearAttachments args;
6671
6672 if (!ctx->dispatch_vkCmdClearAttachments) {
6673 vn_cs_decoder_set_fatal(ctx->decoder);
6674 return;
6675 }
6676
6677 vn_decode_vkCmdClearAttachments_args_temp(ctx->decoder, &args);
6678 if (!args.commandBuffer) {
6679 vn_cs_decoder_set_fatal(ctx->decoder);
6680 return;
6681 }
6682
6683 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6684 ctx->dispatch_vkCmdClearAttachments(ctx, &args);
6685
6686
6687 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6688 vn_encode_vkCmdClearAttachments_reply(ctx->encoder, &args);
6689
6690 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6691 }
6692
vn_dispatch_vkCmdResolveImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6693 static inline void vn_dispatch_vkCmdResolveImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6694 {
6695 struct vn_command_vkCmdResolveImage args;
6696
6697 if (!ctx->dispatch_vkCmdResolveImage) {
6698 vn_cs_decoder_set_fatal(ctx->decoder);
6699 return;
6700 }
6701
6702 vn_decode_vkCmdResolveImage_args_temp(ctx->decoder, &args);
6703 if (!args.commandBuffer) {
6704 vn_cs_decoder_set_fatal(ctx->decoder);
6705 return;
6706 }
6707
6708 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6709 ctx->dispatch_vkCmdResolveImage(ctx, &args);
6710
6711
6712 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6713 vn_encode_vkCmdResolveImage_reply(ctx->encoder, &args);
6714
6715 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6716 }
6717
vn_dispatch_vkCmdSetEvent(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6718 static inline void vn_dispatch_vkCmdSetEvent(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6719 {
6720 struct vn_command_vkCmdSetEvent args;
6721
6722 if (!ctx->dispatch_vkCmdSetEvent) {
6723 vn_cs_decoder_set_fatal(ctx->decoder);
6724 return;
6725 }
6726
6727 vn_decode_vkCmdSetEvent_args_temp(ctx->decoder, &args);
6728 if (!args.commandBuffer) {
6729 vn_cs_decoder_set_fatal(ctx->decoder);
6730 return;
6731 }
6732
6733 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6734 ctx->dispatch_vkCmdSetEvent(ctx, &args);
6735
6736
6737 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6738 vn_encode_vkCmdSetEvent_reply(ctx->encoder, &args);
6739
6740 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6741 }
6742
vn_dispatch_vkCmdResetEvent(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6743 static inline void vn_dispatch_vkCmdResetEvent(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6744 {
6745 struct vn_command_vkCmdResetEvent args;
6746
6747 if (!ctx->dispatch_vkCmdResetEvent) {
6748 vn_cs_decoder_set_fatal(ctx->decoder);
6749 return;
6750 }
6751
6752 vn_decode_vkCmdResetEvent_args_temp(ctx->decoder, &args);
6753 if (!args.commandBuffer) {
6754 vn_cs_decoder_set_fatal(ctx->decoder);
6755 return;
6756 }
6757
6758 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6759 ctx->dispatch_vkCmdResetEvent(ctx, &args);
6760
6761
6762 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6763 vn_encode_vkCmdResetEvent_reply(ctx->encoder, &args);
6764
6765 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6766 }
6767
vn_dispatch_vkCmdWaitEvents(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6768 static inline void vn_dispatch_vkCmdWaitEvents(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6769 {
6770 struct vn_command_vkCmdWaitEvents args;
6771
6772 if (!ctx->dispatch_vkCmdWaitEvents) {
6773 vn_cs_decoder_set_fatal(ctx->decoder);
6774 return;
6775 }
6776
6777 vn_decode_vkCmdWaitEvents_args_temp(ctx->decoder, &args);
6778 if (!args.commandBuffer) {
6779 vn_cs_decoder_set_fatal(ctx->decoder);
6780 return;
6781 }
6782
6783 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6784 ctx->dispatch_vkCmdWaitEvents(ctx, &args);
6785
6786
6787 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6788 vn_encode_vkCmdWaitEvents_reply(ctx->encoder, &args);
6789
6790 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6791 }
6792
vn_dispatch_vkCmdPipelineBarrier(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6793 static inline void vn_dispatch_vkCmdPipelineBarrier(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6794 {
6795 struct vn_command_vkCmdPipelineBarrier args;
6796
6797 if (!ctx->dispatch_vkCmdPipelineBarrier) {
6798 vn_cs_decoder_set_fatal(ctx->decoder);
6799 return;
6800 }
6801
6802 vn_decode_vkCmdPipelineBarrier_args_temp(ctx->decoder, &args);
6803 if (!args.commandBuffer) {
6804 vn_cs_decoder_set_fatal(ctx->decoder);
6805 return;
6806 }
6807
6808 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6809 ctx->dispatch_vkCmdPipelineBarrier(ctx, &args);
6810
6811
6812 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6813 vn_encode_vkCmdPipelineBarrier_reply(ctx->encoder, &args);
6814
6815 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6816 }
6817
vn_dispatch_vkCmdBeginQuery(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6818 static inline void vn_dispatch_vkCmdBeginQuery(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6819 {
6820 struct vn_command_vkCmdBeginQuery args;
6821
6822 if (!ctx->dispatch_vkCmdBeginQuery) {
6823 vn_cs_decoder_set_fatal(ctx->decoder);
6824 return;
6825 }
6826
6827 vn_decode_vkCmdBeginQuery_args_temp(ctx->decoder, &args);
6828 if (!args.commandBuffer) {
6829 vn_cs_decoder_set_fatal(ctx->decoder);
6830 return;
6831 }
6832
6833 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6834 ctx->dispatch_vkCmdBeginQuery(ctx, &args);
6835
6836
6837 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6838 vn_encode_vkCmdBeginQuery_reply(ctx->encoder, &args);
6839
6840 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6841 }
6842
vn_dispatch_vkCmdEndQuery(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6843 static inline void vn_dispatch_vkCmdEndQuery(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6844 {
6845 struct vn_command_vkCmdEndQuery args;
6846
6847 if (!ctx->dispatch_vkCmdEndQuery) {
6848 vn_cs_decoder_set_fatal(ctx->decoder);
6849 return;
6850 }
6851
6852 vn_decode_vkCmdEndQuery_args_temp(ctx->decoder, &args);
6853 if (!args.commandBuffer) {
6854 vn_cs_decoder_set_fatal(ctx->decoder);
6855 return;
6856 }
6857
6858 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6859 ctx->dispatch_vkCmdEndQuery(ctx, &args);
6860
6861
6862 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6863 vn_encode_vkCmdEndQuery_reply(ctx->encoder, &args);
6864
6865 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6866 }
6867
vn_dispatch_vkCmdBeginConditionalRenderingEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6868 static inline void vn_dispatch_vkCmdBeginConditionalRenderingEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6869 {
6870 struct vn_command_vkCmdBeginConditionalRenderingEXT args;
6871
6872 if (!ctx->dispatch_vkCmdBeginConditionalRenderingEXT) {
6873 vn_cs_decoder_set_fatal(ctx->decoder);
6874 return;
6875 }
6876
6877 vn_decode_vkCmdBeginConditionalRenderingEXT_args_temp(ctx->decoder, &args);
6878 if (!args.commandBuffer) {
6879 vn_cs_decoder_set_fatal(ctx->decoder);
6880 return;
6881 }
6882
6883 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6884 ctx->dispatch_vkCmdBeginConditionalRenderingEXT(ctx, &args);
6885
6886
6887 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6888 vn_encode_vkCmdBeginConditionalRenderingEXT_reply(ctx->encoder, &args);
6889
6890 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6891 }
6892
vn_dispatch_vkCmdEndConditionalRenderingEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6893 static inline void vn_dispatch_vkCmdEndConditionalRenderingEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6894 {
6895 struct vn_command_vkCmdEndConditionalRenderingEXT args;
6896
6897 if (!ctx->dispatch_vkCmdEndConditionalRenderingEXT) {
6898 vn_cs_decoder_set_fatal(ctx->decoder);
6899 return;
6900 }
6901
6902 vn_decode_vkCmdEndConditionalRenderingEXT_args_temp(ctx->decoder, &args);
6903 if (!args.commandBuffer) {
6904 vn_cs_decoder_set_fatal(ctx->decoder);
6905 return;
6906 }
6907
6908 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6909 ctx->dispatch_vkCmdEndConditionalRenderingEXT(ctx, &args);
6910
6911
6912 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6913 vn_encode_vkCmdEndConditionalRenderingEXT_reply(ctx->encoder, &args);
6914
6915 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6916 }
6917
vn_dispatch_vkCmdResetQueryPool(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6918 static inline void vn_dispatch_vkCmdResetQueryPool(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6919 {
6920 struct vn_command_vkCmdResetQueryPool args;
6921
6922 if (!ctx->dispatch_vkCmdResetQueryPool) {
6923 vn_cs_decoder_set_fatal(ctx->decoder);
6924 return;
6925 }
6926
6927 vn_decode_vkCmdResetQueryPool_args_temp(ctx->decoder, &args);
6928 if (!args.commandBuffer) {
6929 vn_cs_decoder_set_fatal(ctx->decoder);
6930 return;
6931 }
6932
6933 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6934 ctx->dispatch_vkCmdResetQueryPool(ctx, &args);
6935
6936
6937 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6938 vn_encode_vkCmdResetQueryPool_reply(ctx->encoder, &args);
6939
6940 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6941 }
6942
vn_dispatch_vkCmdWriteTimestamp(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6943 static inline void vn_dispatch_vkCmdWriteTimestamp(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6944 {
6945 struct vn_command_vkCmdWriteTimestamp args;
6946
6947 if (!ctx->dispatch_vkCmdWriteTimestamp) {
6948 vn_cs_decoder_set_fatal(ctx->decoder);
6949 return;
6950 }
6951
6952 vn_decode_vkCmdWriteTimestamp_args_temp(ctx->decoder, &args);
6953 if (!args.commandBuffer) {
6954 vn_cs_decoder_set_fatal(ctx->decoder);
6955 return;
6956 }
6957
6958 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6959 ctx->dispatch_vkCmdWriteTimestamp(ctx, &args);
6960
6961
6962 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6963 vn_encode_vkCmdWriteTimestamp_reply(ctx->encoder, &args);
6964
6965 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6966 }
6967
vn_dispatch_vkCmdCopyQueryPoolResults(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6968 static inline void vn_dispatch_vkCmdCopyQueryPoolResults(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6969 {
6970 struct vn_command_vkCmdCopyQueryPoolResults args;
6971
6972 if (!ctx->dispatch_vkCmdCopyQueryPoolResults) {
6973 vn_cs_decoder_set_fatal(ctx->decoder);
6974 return;
6975 }
6976
6977 vn_decode_vkCmdCopyQueryPoolResults_args_temp(ctx->decoder, &args);
6978 if (!args.commandBuffer) {
6979 vn_cs_decoder_set_fatal(ctx->decoder);
6980 return;
6981 }
6982
6983 if (!vn_cs_decoder_get_fatal(ctx->decoder))
6984 ctx->dispatch_vkCmdCopyQueryPoolResults(ctx, &args);
6985
6986
6987 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
6988 vn_encode_vkCmdCopyQueryPoolResults_reply(ctx->encoder, &args);
6989
6990 vn_cs_decoder_reset_temp_pool(ctx->decoder);
6991 }
6992
vn_dispatch_vkCmdPushConstants(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)6993 static inline void vn_dispatch_vkCmdPushConstants(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
6994 {
6995 struct vn_command_vkCmdPushConstants args;
6996
6997 if (!ctx->dispatch_vkCmdPushConstants) {
6998 vn_cs_decoder_set_fatal(ctx->decoder);
6999 return;
7000 }
7001
7002 vn_decode_vkCmdPushConstants_args_temp(ctx->decoder, &args);
7003 if (!args.commandBuffer) {
7004 vn_cs_decoder_set_fatal(ctx->decoder);
7005 return;
7006 }
7007
7008 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7009 ctx->dispatch_vkCmdPushConstants(ctx, &args);
7010
7011
7012 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7013 vn_encode_vkCmdPushConstants_reply(ctx->encoder, &args);
7014
7015 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7016 }
7017
vn_dispatch_vkCmdBeginRenderPass(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7018 static inline void vn_dispatch_vkCmdBeginRenderPass(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7019 {
7020 struct vn_command_vkCmdBeginRenderPass args;
7021
7022 if (!ctx->dispatch_vkCmdBeginRenderPass) {
7023 vn_cs_decoder_set_fatal(ctx->decoder);
7024 return;
7025 }
7026
7027 vn_decode_vkCmdBeginRenderPass_args_temp(ctx->decoder, &args);
7028 if (!args.commandBuffer) {
7029 vn_cs_decoder_set_fatal(ctx->decoder);
7030 return;
7031 }
7032
7033 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7034 ctx->dispatch_vkCmdBeginRenderPass(ctx, &args);
7035
7036
7037 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7038 vn_encode_vkCmdBeginRenderPass_reply(ctx->encoder, &args);
7039
7040 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7041 }
7042
vn_dispatch_vkCmdNextSubpass(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7043 static inline void vn_dispatch_vkCmdNextSubpass(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7044 {
7045 struct vn_command_vkCmdNextSubpass args;
7046
7047 if (!ctx->dispatch_vkCmdNextSubpass) {
7048 vn_cs_decoder_set_fatal(ctx->decoder);
7049 return;
7050 }
7051
7052 vn_decode_vkCmdNextSubpass_args_temp(ctx->decoder, &args);
7053 if (!args.commandBuffer) {
7054 vn_cs_decoder_set_fatal(ctx->decoder);
7055 return;
7056 }
7057
7058 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7059 ctx->dispatch_vkCmdNextSubpass(ctx, &args);
7060
7061
7062 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7063 vn_encode_vkCmdNextSubpass_reply(ctx->encoder, &args);
7064
7065 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7066 }
7067
vn_dispatch_vkCmdEndRenderPass(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7068 static inline void vn_dispatch_vkCmdEndRenderPass(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7069 {
7070 struct vn_command_vkCmdEndRenderPass args;
7071
7072 if (!ctx->dispatch_vkCmdEndRenderPass) {
7073 vn_cs_decoder_set_fatal(ctx->decoder);
7074 return;
7075 }
7076
7077 vn_decode_vkCmdEndRenderPass_args_temp(ctx->decoder, &args);
7078 if (!args.commandBuffer) {
7079 vn_cs_decoder_set_fatal(ctx->decoder);
7080 return;
7081 }
7082
7083 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7084 ctx->dispatch_vkCmdEndRenderPass(ctx, &args);
7085
7086
7087 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7088 vn_encode_vkCmdEndRenderPass_reply(ctx->encoder, &args);
7089
7090 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7091 }
7092
vn_dispatch_vkCmdExecuteCommands(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7093 static inline void vn_dispatch_vkCmdExecuteCommands(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7094 {
7095 struct vn_command_vkCmdExecuteCommands args;
7096
7097 if (!ctx->dispatch_vkCmdExecuteCommands) {
7098 vn_cs_decoder_set_fatal(ctx->decoder);
7099 return;
7100 }
7101
7102 vn_decode_vkCmdExecuteCommands_args_temp(ctx->decoder, &args);
7103 if (!args.commandBuffer) {
7104 vn_cs_decoder_set_fatal(ctx->decoder);
7105 return;
7106 }
7107
7108 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7109 ctx->dispatch_vkCmdExecuteCommands(ctx, &args);
7110
7111
7112 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7113 vn_encode_vkCmdExecuteCommands_reply(ctx->encoder, &args);
7114
7115 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7116 }
7117
vn_dispatch_vkCmdPushDescriptorSetKHR(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7118 static inline void vn_dispatch_vkCmdPushDescriptorSetKHR(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7119 {
7120 struct vn_command_vkCmdPushDescriptorSetKHR args;
7121
7122 if (!ctx->dispatch_vkCmdPushDescriptorSetKHR) {
7123 vn_cs_decoder_set_fatal(ctx->decoder);
7124 return;
7125 }
7126
7127 vn_decode_vkCmdPushDescriptorSetKHR_args_temp(ctx->decoder, &args);
7128 if (!args.commandBuffer) {
7129 vn_cs_decoder_set_fatal(ctx->decoder);
7130 return;
7131 }
7132
7133 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7134 ctx->dispatch_vkCmdPushDescriptorSetKHR(ctx, &args);
7135
7136
7137 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7138 vn_encode_vkCmdPushDescriptorSetKHR_reply(ctx->encoder, &args);
7139
7140 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7141 }
7142
vn_dispatch_vkCmdSetDeviceMask(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7143 static inline void vn_dispatch_vkCmdSetDeviceMask(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7144 {
7145 struct vn_command_vkCmdSetDeviceMask args;
7146
7147 if (!ctx->dispatch_vkCmdSetDeviceMask) {
7148 vn_cs_decoder_set_fatal(ctx->decoder);
7149 return;
7150 }
7151
7152 vn_decode_vkCmdSetDeviceMask_args_temp(ctx->decoder, &args);
7153 if (!args.commandBuffer) {
7154 vn_cs_decoder_set_fatal(ctx->decoder);
7155 return;
7156 }
7157
7158 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7159 ctx->dispatch_vkCmdSetDeviceMask(ctx, &args);
7160
7161
7162 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7163 vn_encode_vkCmdSetDeviceMask_reply(ctx->encoder, &args);
7164
7165 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7166 }
7167
vn_dispatch_vkCmdDispatchBase(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7168 static inline void vn_dispatch_vkCmdDispatchBase(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7169 {
7170 struct vn_command_vkCmdDispatchBase args;
7171
7172 if (!ctx->dispatch_vkCmdDispatchBase) {
7173 vn_cs_decoder_set_fatal(ctx->decoder);
7174 return;
7175 }
7176
7177 vn_decode_vkCmdDispatchBase_args_temp(ctx->decoder, &args);
7178 if (!args.commandBuffer) {
7179 vn_cs_decoder_set_fatal(ctx->decoder);
7180 return;
7181 }
7182
7183 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7184 ctx->dispatch_vkCmdDispatchBase(ctx, &args);
7185
7186
7187 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7188 vn_encode_vkCmdDispatchBase_reply(ctx->encoder, &args);
7189
7190 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7191 }
7192
vn_dispatch_vkCmdBeginRenderPass2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7193 static inline void vn_dispatch_vkCmdBeginRenderPass2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7194 {
7195 struct vn_command_vkCmdBeginRenderPass2 args;
7196
7197 if (!ctx->dispatch_vkCmdBeginRenderPass2) {
7198 vn_cs_decoder_set_fatal(ctx->decoder);
7199 return;
7200 }
7201
7202 vn_decode_vkCmdBeginRenderPass2_args_temp(ctx->decoder, &args);
7203 if (!args.commandBuffer) {
7204 vn_cs_decoder_set_fatal(ctx->decoder);
7205 return;
7206 }
7207
7208 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7209 ctx->dispatch_vkCmdBeginRenderPass2(ctx, &args);
7210
7211
7212 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7213 vn_encode_vkCmdBeginRenderPass2_reply(ctx->encoder, &args);
7214
7215 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7216 }
7217
vn_dispatch_vkCmdNextSubpass2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7218 static inline void vn_dispatch_vkCmdNextSubpass2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7219 {
7220 struct vn_command_vkCmdNextSubpass2 args;
7221
7222 if (!ctx->dispatch_vkCmdNextSubpass2) {
7223 vn_cs_decoder_set_fatal(ctx->decoder);
7224 return;
7225 }
7226
7227 vn_decode_vkCmdNextSubpass2_args_temp(ctx->decoder, &args);
7228 if (!args.commandBuffer) {
7229 vn_cs_decoder_set_fatal(ctx->decoder);
7230 return;
7231 }
7232
7233 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7234 ctx->dispatch_vkCmdNextSubpass2(ctx, &args);
7235
7236
7237 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7238 vn_encode_vkCmdNextSubpass2_reply(ctx->encoder, &args);
7239
7240 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7241 }
7242
vn_dispatch_vkCmdEndRenderPass2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7243 static inline void vn_dispatch_vkCmdEndRenderPass2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7244 {
7245 struct vn_command_vkCmdEndRenderPass2 args;
7246
7247 if (!ctx->dispatch_vkCmdEndRenderPass2) {
7248 vn_cs_decoder_set_fatal(ctx->decoder);
7249 return;
7250 }
7251
7252 vn_decode_vkCmdEndRenderPass2_args_temp(ctx->decoder, &args);
7253 if (!args.commandBuffer) {
7254 vn_cs_decoder_set_fatal(ctx->decoder);
7255 return;
7256 }
7257
7258 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7259 ctx->dispatch_vkCmdEndRenderPass2(ctx, &args);
7260
7261
7262 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7263 vn_encode_vkCmdEndRenderPass2_reply(ctx->encoder, &args);
7264
7265 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7266 }
7267
vn_dispatch_vkCmdDrawIndirectCount(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7268 static inline void vn_dispatch_vkCmdDrawIndirectCount(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7269 {
7270 struct vn_command_vkCmdDrawIndirectCount args;
7271
7272 if (!ctx->dispatch_vkCmdDrawIndirectCount) {
7273 vn_cs_decoder_set_fatal(ctx->decoder);
7274 return;
7275 }
7276
7277 vn_decode_vkCmdDrawIndirectCount_args_temp(ctx->decoder, &args);
7278 if (!args.commandBuffer) {
7279 vn_cs_decoder_set_fatal(ctx->decoder);
7280 return;
7281 }
7282
7283 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7284 ctx->dispatch_vkCmdDrawIndirectCount(ctx, &args);
7285
7286
7287 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7288 vn_encode_vkCmdDrawIndirectCount_reply(ctx->encoder, &args);
7289
7290 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7291 }
7292
vn_dispatch_vkCmdDrawIndexedIndirectCount(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7293 static inline void vn_dispatch_vkCmdDrawIndexedIndirectCount(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7294 {
7295 struct vn_command_vkCmdDrawIndexedIndirectCount args;
7296
7297 if (!ctx->dispatch_vkCmdDrawIndexedIndirectCount) {
7298 vn_cs_decoder_set_fatal(ctx->decoder);
7299 return;
7300 }
7301
7302 vn_decode_vkCmdDrawIndexedIndirectCount_args_temp(ctx->decoder, &args);
7303 if (!args.commandBuffer) {
7304 vn_cs_decoder_set_fatal(ctx->decoder);
7305 return;
7306 }
7307
7308 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7309 ctx->dispatch_vkCmdDrawIndexedIndirectCount(ctx, &args);
7310
7311
7312 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7313 vn_encode_vkCmdDrawIndexedIndirectCount_reply(ctx->encoder, &args);
7314
7315 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7316 }
7317
vn_dispatch_vkCmdBindTransformFeedbackBuffersEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7318 static inline void vn_dispatch_vkCmdBindTransformFeedbackBuffersEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7319 {
7320 struct vn_command_vkCmdBindTransformFeedbackBuffersEXT args;
7321
7322 if (!ctx->dispatch_vkCmdBindTransformFeedbackBuffersEXT) {
7323 vn_cs_decoder_set_fatal(ctx->decoder);
7324 return;
7325 }
7326
7327 vn_decode_vkCmdBindTransformFeedbackBuffersEXT_args_temp(ctx->decoder, &args);
7328 if (!args.commandBuffer) {
7329 vn_cs_decoder_set_fatal(ctx->decoder);
7330 return;
7331 }
7332
7333 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7334 ctx->dispatch_vkCmdBindTransformFeedbackBuffersEXT(ctx, &args);
7335
7336
7337 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7338 vn_encode_vkCmdBindTransformFeedbackBuffersEXT_reply(ctx->encoder, &args);
7339
7340 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7341 }
7342
vn_dispatch_vkCmdBeginTransformFeedbackEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7343 static inline void vn_dispatch_vkCmdBeginTransformFeedbackEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7344 {
7345 struct vn_command_vkCmdBeginTransformFeedbackEXT args;
7346
7347 if (!ctx->dispatch_vkCmdBeginTransformFeedbackEXT) {
7348 vn_cs_decoder_set_fatal(ctx->decoder);
7349 return;
7350 }
7351
7352 vn_decode_vkCmdBeginTransformFeedbackEXT_args_temp(ctx->decoder, &args);
7353 if (!args.commandBuffer) {
7354 vn_cs_decoder_set_fatal(ctx->decoder);
7355 return;
7356 }
7357
7358 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7359 ctx->dispatch_vkCmdBeginTransformFeedbackEXT(ctx, &args);
7360
7361
7362 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7363 vn_encode_vkCmdBeginTransformFeedbackEXT_reply(ctx->encoder, &args);
7364
7365 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7366 }
7367
vn_dispatch_vkCmdEndTransformFeedbackEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7368 static inline void vn_dispatch_vkCmdEndTransformFeedbackEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7369 {
7370 struct vn_command_vkCmdEndTransformFeedbackEXT args;
7371
7372 if (!ctx->dispatch_vkCmdEndTransformFeedbackEXT) {
7373 vn_cs_decoder_set_fatal(ctx->decoder);
7374 return;
7375 }
7376
7377 vn_decode_vkCmdEndTransformFeedbackEXT_args_temp(ctx->decoder, &args);
7378 if (!args.commandBuffer) {
7379 vn_cs_decoder_set_fatal(ctx->decoder);
7380 return;
7381 }
7382
7383 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7384 ctx->dispatch_vkCmdEndTransformFeedbackEXT(ctx, &args);
7385
7386
7387 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7388 vn_encode_vkCmdEndTransformFeedbackEXT_reply(ctx->encoder, &args);
7389
7390 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7391 }
7392
vn_dispatch_vkCmdBeginQueryIndexedEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7393 static inline void vn_dispatch_vkCmdBeginQueryIndexedEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7394 {
7395 struct vn_command_vkCmdBeginQueryIndexedEXT args;
7396
7397 if (!ctx->dispatch_vkCmdBeginQueryIndexedEXT) {
7398 vn_cs_decoder_set_fatal(ctx->decoder);
7399 return;
7400 }
7401
7402 vn_decode_vkCmdBeginQueryIndexedEXT_args_temp(ctx->decoder, &args);
7403 if (!args.commandBuffer) {
7404 vn_cs_decoder_set_fatal(ctx->decoder);
7405 return;
7406 }
7407
7408 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7409 ctx->dispatch_vkCmdBeginQueryIndexedEXT(ctx, &args);
7410
7411
7412 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7413 vn_encode_vkCmdBeginQueryIndexedEXT_reply(ctx->encoder, &args);
7414
7415 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7416 }
7417
vn_dispatch_vkCmdEndQueryIndexedEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7418 static inline void vn_dispatch_vkCmdEndQueryIndexedEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7419 {
7420 struct vn_command_vkCmdEndQueryIndexedEXT args;
7421
7422 if (!ctx->dispatch_vkCmdEndQueryIndexedEXT) {
7423 vn_cs_decoder_set_fatal(ctx->decoder);
7424 return;
7425 }
7426
7427 vn_decode_vkCmdEndQueryIndexedEXT_args_temp(ctx->decoder, &args);
7428 if (!args.commandBuffer) {
7429 vn_cs_decoder_set_fatal(ctx->decoder);
7430 return;
7431 }
7432
7433 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7434 ctx->dispatch_vkCmdEndQueryIndexedEXT(ctx, &args);
7435
7436
7437 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7438 vn_encode_vkCmdEndQueryIndexedEXT_reply(ctx->encoder, &args);
7439
7440 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7441 }
7442
vn_dispatch_vkCmdDrawIndirectByteCountEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7443 static inline void vn_dispatch_vkCmdDrawIndirectByteCountEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7444 {
7445 struct vn_command_vkCmdDrawIndirectByteCountEXT args;
7446
7447 if (!ctx->dispatch_vkCmdDrawIndirectByteCountEXT) {
7448 vn_cs_decoder_set_fatal(ctx->decoder);
7449 return;
7450 }
7451
7452 vn_decode_vkCmdDrawIndirectByteCountEXT_args_temp(ctx->decoder, &args);
7453 if (!args.commandBuffer) {
7454 vn_cs_decoder_set_fatal(ctx->decoder);
7455 return;
7456 }
7457
7458 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7459 ctx->dispatch_vkCmdDrawIndirectByteCountEXT(ctx, &args);
7460
7461
7462 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7463 vn_encode_vkCmdDrawIndirectByteCountEXT_reply(ctx->encoder, &args);
7464
7465 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7466 }
7467
vn_dispatch_vkCmdSetLineStippleEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7468 static inline void vn_dispatch_vkCmdSetLineStippleEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7469 {
7470 struct vn_command_vkCmdSetLineStippleEXT args;
7471
7472 if (!ctx->dispatch_vkCmdSetLineStippleEXT) {
7473 vn_cs_decoder_set_fatal(ctx->decoder);
7474 return;
7475 }
7476
7477 vn_decode_vkCmdSetLineStippleEXT_args_temp(ctx->decoder, &args);
7478 if (!args.commandBuffer) {
7479 vn_cs_decoder_set_fatal(ctx->decoder);
7480 return;
7481 }
7482
7483 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7484 ctx->dispatch_vkCmdSetLineStippleEXT(ctx, &args);
7485
7486
7487 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7488 vn_encode_vkCmdSetLineStippleEXT_reply(ctx->encoder, &args);
7489
7490 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7491 }
7492
vn_dispatch_vkCmdSetCullMode(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7493 static inline void vn_dispatch_vkCmdSetCullMode(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7494 {
7495 struct vn_command_vkCmdSetCullMode args;
7496
7497 if (!ctx->dispatch_vkCmdSetCullMode) {
7498 vn_cs_decoder_set_fatal(ctx->decoder);
7499 return;
7500 }
7501
7502 vn_decode_vkCmdSetCullMode_args_temp(ctx->decoder, &args);
7503 if (!args.commandBuffer) {
7504 vn_cs_decoder_set_fatal(ctx->decoder);
7505 return;
7506 }
7507
7508 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7509 ctx->dispatch_vkCmdSetCullMode(ctx, &args);
7510
7511
7512 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7513 vn_encode_vkCmdSetCullMode_reply(ctx->encoder, &args);
7514
7515 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7516 }
7517
vn_dispatch_vkCmdSetFrontFace(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7518 static inline void vn_dispatch_vkCmdSetFrontFace(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7519 {
7520 struct vn_command_vkCmdSetFrontFace args;
7521
7522 if (!ctx->dispatch_vkCmdSetFrontFace) {
7523 vn_cs_decoder_set_fatal(ctx->decoder);
7524 return;
7525 }
7526
7527 vn_decode_vkCmdSetFrontFace_args_temp(ctx->decoder, &args);
7528 if (!args.commandBuffer) {
7529 vn_cs_decoder_set_fatal(ctx->decoder);
7530 return;
7531 }
7532
7533 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7534 ctx->dispatch_vkCmdSetFrontFace(ctx, &args);
7535
7536
7537 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7538 vn_encode_vkCmdSetFrontFace_reply(ctx->encoder, &args);
7539
7540 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7541 }
7542
vn_dispatch_vkCmdSetPrimitiveTopology(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7543 static inline void vn_dispatch_vkCmdSetPrimitiveTopology(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7544 {
7545 struct vn_command_vkCmdSetPrimitiveTopology args;
7546
7547 if (!ctx->dispatch_vkCmdSetPrimitiveTopology) {
7548 vn_cs_decoder_set_fatal(ctx->decoder);
7549 return;
7550 }
7551
7552 vn_decode_vkCmdSetPrimitiveTopology_args_temp(ctx->decoder, &args);
7553 if (!args.commandBuffer) {
7554 vn_cs_decoder_set_fatal(ctx->decoder);
7555 return;
7556 }
7557
7558 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7559 ctx->dispatch_vkCmdSetPrimitiveTopology(ctx, &args);
7560
7561
7562 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7563 vn_encode_vkCmdSetPrimitiveTopology_reply(ctx->encoder, &args);
7564
7565 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7566 }
7567
vn_dispatch_vkCmdSetViewportWithCount(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7568 static inline void vn_dispatch_vkCmdSetViewportWithCount(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7569 {
7570 struct vn_command_vkCmdSetViewportWithCount args;
7571
7572 if (!ctx->dispatch_vkCmdSetViewportWithCount) {
7573 vn_cs_decoder_set_fatal(ctx->decoder);
7574 return;
7575 }
7576
7577 vn_decode_vkCmdSetViewportWithCount_args_temp(ctx->decoder, &args);
7578 if (!args.commandBuffer) {
7579 vn_cs_decoder_set_fatal(ctx->decoder);
7580 return;
7581 }
7582
7583 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7584 ctx->dispatch_vkCmdSetViewportWithCount(ctx, &args);
7585
7586
7587 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7588 vn_encode_vkCmdSetViewportWithCount_reply(ctx->encoder, &args);
7589
7590 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7591 }
7592
vn_dispatch_vkCmdSetScissorWithCount(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7593 static inline void vn_dispatch_vkCmdSetScissorWithCount(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7594 {
7595 struct vn_command_vkCmdSetScissorWithCount args;
7596
7597 if (!ctx->dispatch_vkCmdSetScissorWithCount) {
7598 vn_cs_decoder_set_fatal(ctx->decoder);
7599 return;
7600 }
7601
7602 vn_decode_vkCmdSetScissorWithCount_args_temp(ctx->decoder, &args);
7603 if (!args.commandBuffer) {
7604 vn_cs_decoder_set_fatal(ctx->decoder);
7605 return;
7606 }
7607
7608 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7609 ctx->dispatch_vkCmdSetScissorWithCount(ctx, &args);
7610
7611
7612 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7613 vn_encode_vkCmdSetScissorWithCount_reply(ctx->encoder, &args);
7614
7615 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7616 }
7617
vn_dispatch_vkCmdBindVertexBuffers2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7618 static inline void vn_dispatch_vkCmdBindVertexBuffers2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7619 {
7620 struct vn_command_vkCmdBindVertexBuffers2 args;
7621
7622 if (!ctx->dispatch_vkCmdBindVertexBuffers2) {
7623 vn_cs_decoder_set_fatal(ctx->decoder);
7624 return;
7625 }
7626
7627 vn_decode_vkCmdBindVertexBuffers2_args_temp(ctx->decoder, &args);
7628 if (!args.commandBuffer) {
7629 vn_cs_decoder_set_fatal(ctx->decoder);
7630 return;
7631 }
7632
7633 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7634 ctx->dispatch_vkCmdBindVertexBuffers2(ctx, &args);
7635
7636
7637 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7638 vn_encode_vkCmdBindVertexBuffers2_reply(ctx->encoder, &args);
7639
7640 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7641 }
7642
vn_dispatch_vkCmdSetDepthTestEnable(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7643 static inline void vn_dispatch_vkCmdSetDepthTestEnable(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7644 {
7645 struct vn_command_vkCmdSetDepthTestEnable args;
7646
7647 if (!ctx->dispatch_vkCmdSetDepthTestEnable) {
7648 vn_cs_decoder_set_fatal(ctx->decoder);
7649 return;
7650 }
7651
7652 vn_decode_vkCmdSetDepthTestEnable_args_temp(ctx->decoder, &args);
7653 if (!args.commandBuffer) {
7654 vn_cs_decoder_set_fatal(ctx->decoder);
7655 return;
7656 }
7657
7658 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7659 ctx->dispatch_vkCmdSetDepthTestEnable(ctx, &args);
7660
7661
7662 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7663 vn_encode_vkCmdSetDepthTestEnable_reply(ctx->encoder, &args);
7664
7665 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7666 }
7667
vn_dispatch_vkCmdSetDepthWriteEnable(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7668 static inline void vn_dispatch_vkCmdSetDepthWriteEnable(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7669 {
7670 struct vn_command_vkCmdSetDepthWriteEnable args;
7671
7672 if (!ctx->dispatch_vkCmdSetDepthWriteEnable) {
7673 vn_cs_decoder_set_fatal(ctx->decoder);
7674 return;
7675 }
7676
7677 vn_decode_vkCmdSetDepthWriteEnable_args_temp(ctx->decoder, &args);
7678 if (!args.commandBuffer) {
7679 vn_cs_decoder_set_fatal(ctx->decoder);
7680 return;
7681 }
7682
7683 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7684 ctx->dispatch_vkCmdSetDepthWriteEnable(ctx, &args);
7685
7686
7687 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7688 vn_encode_vkCmdSetDepthWriteEnable_reply(ctx->encoder, &args);
7689
7690 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7691 }
7692
vn_dispatch_vkCmdSetDepthCompareOp(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7693 static inline void vn_dispatch_vkCmdSetDepthCompareOp(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7694 {
7695 struct vn_command_vkCmdSetDepthCompareOp args;
7696
7697 if (!ctx->dispatch_vkCmdSetDepthCompareOp) {
7698 vn_cs_decoder_set_fatal(ctx->decoder);
7699 return;
7700 }
7701
7702 vn_decode_vkCmdSetDepthCompareOp_args_temp(ctx->decoder, &args);
7703 if (!args.commandBuffer) {
7704 vn_cs_decoder_set_fatal(ctx->decoder);
7705 return;
7706 }
7707
7708 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7709 ctx->dispatch_vkCmdSetDepthCompareOp(ctx, &args);
7710
7711
7712 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7713 vn_encode_vkCmdSetDepthCompareOp_reply(ctx->encoder, &args);
7714
7715 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7716 }
7717
vn_dispatch_vkCmdSetDepthBoundsTestEnable(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7718 static inline void vn_dispatch_vkCmdSetDepthBoundsTestEnable(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7719 {
7720 struct vn_command_vkCmdSetDepthBoundsTestEnable args;
7721
7722 if (!ctx->dispatch_vkCmdSetDepthBoundsTestEnable) {
7723 vn_cs_decoder_set_fatal(ctx->decoder);
7724 return;
7725 }
7726
7727 vn_decode_vkCmdSetDepthBoundsTestEnable_args_temp(ctx->decoder, &args);
7728 if (!args.commandBuffer) {
7729 vn_cs_decoder_set_fatal(ctx->decoder);
7730 return;
7731 }
7732
7733 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7734 ctx->dispatch_vkCmdSetDepthBoundsTestEnable(ctx, &args);
7735
7736
7737 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7738 vn_encode_vkCmdSetDepthBoundsTestEnable_reply(ctx->encoder, &args);
7739
7740 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7741 }
7742
vn_dispatch_vkCmdSetStencilTestEnable(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7743 static inline void vn_dispatch_vkCmdSetStencilTestEnable(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7744 {
7745 struct vn_command_vkCmdSetStencilTestEnable args;
7746
7747 if (!ctx->dispatch_vkCmdSetStencilTestEnable) {
7748 vn_cs_decoder_set_fatal(ctx->decoder);
7749 return;
7750 }
7751
7752 vn_decode_vkCmdSetStencilTestEnable_args_temp(ctx->decoder, &args);
7753 if (!args.commandBuffer) {
7754 vn_cs_decoder_set_fatal(ctx->decoder);
7755 return;
7756 }
7757
7758 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7759 ctx->dispatch_vkCmdSetStencilTestEnable(ctx, &args);
7760
7761
7762 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7763 vn_encode_vkCmdSetStencilTestEnable_reply(ctx->encoder, &args);
7764
7765 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7766 }
7767
vn_dispatch_vkCmdSetStencilOp(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7768 static inline void vn_dispatch_vkCmdSetStencilOp(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7769 {
7770 struct vn_command_vkCmdSetStencilOp args;
7771
7772 if (!ctx->dispatch_vkCmdSetStencilOp) {
7773 vn_cs_decoder_set_fatal(ctx->decoder);
7774 return;
7775 }
7776
7777 vn_decode_vkCmdSetStencilOp_args_temp(ctx->decoder, &args);
7778 if (!args.commandBuffer) {
7779 vn_cs_decoder_set_fatal(ctx->decoder);
7780 return;
7781 }
7782
7783 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7784 ctx->dispatch_vkCmdSetStencilOp(ctx, &args);
7785
7786
7787 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7788 vn_encode_vkCmdSetStencilOp_reply(ctx->encoder, &args);
7789
7790 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7791 }
7792
vn_dispatch_vkCmdSetPatchControlPointsEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7793 static inline void vn_dispatch_vkCmdSetPatchControlPointsEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7794 {
7795 struct vn_command_vkCmdSetPatchControlPointsEXT args;
7796
7797 if (!ctx->dispatch_vkCmdSetPatchControlPointsEXT) {
7798 vn_cs_decoder_set_fatal(ctx->decoder);
7799 return;
7800 }
7801
7802 vn_decode_vkCmdSetPatchControlPointsEXT_args_temp(ctx->decoder, &args);
7803 if (!args.commandBuffer) {
7804 vn_cs_decoder_set_fatal(ctx->decoder);
7805 return;
7806 }
7807
7808 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7809 ctx->dispatch_vkCmdSetPatchControlPointsEXT(ctx, &args);
7810
7811
7812 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7813 vn_encode_vkCmdSetPatchControlPointsEXT_reply(ctx->encoder, &args);
7814
7815 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7816 }
7817
vn_dispatch_vkCmdSetRasterizerDiscardEnable(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7818 static inline void vn_dispatch_vkCmdSetRasterizerDiscardEnable(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7819 {
7820 struct vn_command_vkCmdSetRasterizerDiscardEnable args;
7821
7822 if (!ctx->dispatch_vkCmdSetRasterizerDiscardEnable) {
7823 vn_cs_decoder_set_fatal(ctx->decoder);
7824 return;
7825 }
7826
7827 vn_decode_vkCmdSetRasterizerDiscardEnable_args_temp(ctx->decoder, &args);
7828 if (!args.commandBuffer) {
7829 vn_cs_decoder_set_fatal(ctx->decoder);
7830 return;
7831 }
7832
7833 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7834 ctx->dispatch_vkCmdSetRasterizerDiscardEnable(ctx, &args);
7835
7836
7837 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7838 vn_encode_vkCmdSetRasterizerDiscardEnable_reply(ctx->encoder, &args);
7839
7840 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7841 }
7842
vn_dispatch_vkCmdSetDepthBiasEnable(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7843 static inline void vn_dispatch_vkCmdSetDepthBiasEnable(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7844 {
7845 struct vn_command_vkCmdSetDepthBiasEnable args;
7846
7847 if (!ctx->dispatch_vkCmdSetDepthBiasEnable) {
7848 vn_cs_decoder_set_fatal(ctx->decoder);
7849 return;
7850 }
7851
7852 vn_decode_vkCmdSetDepthBiasEnable_args_temp(ctx->decoder, &args);
7853 if (!args.commandBuffer) {
7854 vn_cs_decoder_set_fatal(ctx->decoder);
7855 return;
7856 }
7857
7858 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7859 ctx->dispatch_vkCmdSetDepthBiasEnable(ctx, &args);
7860
7861
7862 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7863 vn_encode_vkCmdSetDepthBiasEnable_reply(ctx->encoder, &args);
7864
7865 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7866 }
7867
vn_dispatch_vkCmdSetLogicOpEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7868 static inline void vn_dispatch_vkCmdSetLogicOpEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7869 {
7870 struct vn_command_vkCmdSetLogicOpEXT args;
7871
7872 if (!ctx->dispatch_vkCmdSetLogicOpEXT) {
7873 vn_cs_decoder_set_fatal(ctx->decoder);
7874 return;
7875 }
7876
7877 vn_decode_vkCmdSetLogicOpEXT_args_temp(ctx->decoder, &args);
7878 if (!args.commandBuffer) {
7879 vn_cs_decoder_set_fatal(ctx->decoder);
7880 return;
7881 }
7882
7883 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7884 ctx->dispatch_vkCmdSetLogicOpEXT(ctx, &args);
7885
7886
7887 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7888 vn_encode_vkCmdSetLogicOpEXT_reply(ctx->encoder, &args);
7889
7890 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7891 }
7892
vn_dispatch_vkCmdSetPrimitiveRestartEnable(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7893 static inline void vn_dispatch_vkCmdSetPrimitiveRestartEnable(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7894 {
7895 struct vn_command_vkCmdSetPrimitiveRestartEnable args;
7896
7897 if (!ctx->dispatch_vkCmdSetPrimitiveRestartEnable) {
7898 vn_cs_decoder_set_fatal(ctx->decoder);
7899 return;
7900 }
7901
7902 vn_decode_vkCmdSetPrimitiveRestartEnable_args_temp(ctx->decoder, &args);
7903 if (!args.commandBuffer) {
7904 vn_cs_decoder_set_fatal(ctx->decoder);
7905 return;
7906 }
7907
7908 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7909 ctx->dispatch_vkCmdSetPrimitiveRestartEnable(ctx, &args);
7910
7911
7912 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7913 vn_encode_vkCmdSetPrimitiveRestartEnable_reply(ctx->encoder, &args);
7914
7915 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7916 }
7917
vn_dispatch_vkCmdCopyBuffer2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7918 static inline void vn_dispatch_vkCmdCopyBuffer2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7919 {
7920 struct vn_command_vkCmdCopyBuffer2 args;
7921
7922 if (!ctx->dispatch_vkCmdCopyBuffer2) {
7923 vn_cs_decoder_set_fatal(ctx->decoder);
7924 return;
7925 }
7926
7927 vn_decode_vkCmdCopyBuffer2_args_temp(ctx->decoder, &args);
7928 if (!args.commandBuffer) {
7929 vn_cs_decoder_set_fatal(ctx->decoder);
7930 return;
7931 }
7932
7933 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7934 ctx->dispatch_vkCmdCopyBuffer2(ctx, &args);
7935
7936
7937 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7938 vn_encode_vkCmdCopyBuffer2_reply(ctx->encoder, &args);
7939
7940 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7941 }
7942
vn_dispatch_vkCmdCopyImage2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7943 static inline void vn_dispatch_vkCmdCopyImage2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7944 {
7945 struct vn_command_vkCmdCopyImage2 args;
7946
7947 if (!ctx->dispatch_vkCmdCopyImage2) {
7948 vn_cs_decoder_set_fatal(ctx->decoder);
7949 return;
7950 }
7951
7952 vn_decode_vkCmdCopyImage2_args_temp(ctx->decoder, &args);
7953 if (!args.commandBuffer) {
7954 vn_cs_decoder_set_fatal(ctx->decoder);
7955 return;
7956 }
7957
7958 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7959 ctx->dispatch_vkCmdCopyImage2(ctx, &args);
7960
7961
7962 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7963 vn_encode_vkCmdCopyImage2_reply(ctx->encoder, &args);
7964
7965 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7966 }
7967
vn_dispatch_vkCmdBlitImage2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7968 static inline void vn_dispatch_vkCmdBlitImage2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7969 {
7970 struct vn_command_vkCmdBlitImage2 args;
7971
7972 if (!ctx->dispatch_vkCmdBlitImage2) {
7973 vn_cs_decoder_set_fatal(ctx->decoder);
7974 return;
7975 }
7976
7977 vn_decode_vkCmdBlitImage2_args_temp(ctx->decoder, &args);
7978 if (!args.commandBuffer) {
7979 vn_cs_decoder_set_fatal(ctx->decoder);
7980 return;
7981 }
7982
7983 if (!vn_cs_decoder_get_fatal(ctx->decoder))
7984 ctx->dispatch_vkCmdBlitImage2(ctx, &args);
7985
7986
7987 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
7988 vn_encode_vkCmdBlitImage2_reply(ctx->encoder, &args);
7989
7990 vn_cs_decoder_reset_temp_pool(ctx->decoder);
7991 }
7992
vn_dispatch_vkCmdCopyBufferToImage2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)7993 static inline void vn_dispatch_vkCmdCopyBufferToImage2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
7994 {
7995 struct vn_command_vkCmdCopyBufferToImage2 args;
7996
7997 if (!ctx->dispatch_vkCmdCopyBufferToImage2) {
7998 vn_cs_decoder_set_fatal(ctx->decoder);
7999 return;
8000 }
8001
8002 vn_decode_vkCmdCopyBufferToImage2_args_temp(ctx->decoder, &args);
8003 if (!args.commandBuffer) {
8004 vn_cs_decoder_set_fatal(ctx->decoder);
8005 return;
8006 }
8007
8008 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8009 ctx->dispatch_vkCmdCopyBufferToImage2(ctx, &args);
8010
8011
8012 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8013 vn_encode_vkCmdCopyBufferToImage2_reply(ctx->encoder, &args);
8014
8015 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8016 }
8017
vn_dispatch_vkCmdCopyImageToBuffer2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8018 static inline void vn_dispatch_vkCmdCopyImageToBuffer2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8019 {
8020 struct vn_command_vkCmdCopyImageToBuffer2 args;
8021
8022 if (!ctx->dispatch_vkCmdCopyImageToBuffer2) {
8023 vn_cs_decoder_set_fatal(ctx->decoder);
8024 return;
8025 }
8026
8027 vn_decode_vkCmdCopyImageToBuffer2_args_temp(ctx->decoder, &args);
8028 if (!args.commandBuffer) {
8029 vn_cs_decoder_set_fatal(ctx->decoder);
8030 return;
8031 }
8032
8033 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8034 ctx->dispatch_vkCmdCopyImageToBuffer2(ctx, &args);
8035
8036
8037 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8038 vn_encode_vkCmdCopyImageToBuffer2_reply(ctx->encoder, &args);
8039
8040 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8041 }
8042
vn_dispatch_vkCmdResolveImage2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8043 static inline void vn_dispatch_vkCmdResolveImage2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8044 {
8045 struct vn_command_vkCmdResolveImage2 args;
8046
8047 if (!ctx->dispatch_vkCmdResolveImage2) {
8048 vn_cs_decoder_set_fatal(ctx->decoder);
8049 return;
8050 }
8051
8052 vn_decode_vkCmdResolveImage2_args_temp(ctx->decoder, &args);
8053 if (!args.commandBuffer) {
8054 vn_cs_decoder_set_fatal(ctx->decoder);
8055 return;
8056 }
8057
8058 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8059 ctx->dispatch_vkCmdResolveImage2(ctx, &args);
8060
8061
8062 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8063 vn_encode_vkCmdResolveImage2_reply(ctx->encoder, &args);
8064
8065 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8066 }
8067
vn_dispatch_vkCmdSetEvent2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8068 static inline void vn_dispatch_vkCmdSetEvent2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8069 {
8070 struct vn_command_vkCmdSetEvent2 args;
8071
8072 if (!ctx->dispatch_vkCmdSetEvent2) {
8073 vn_cs_decoder_set_fatal(ctx->decoder);
8074 return;
8075 }
8076
8077 vn_decode_vkCmdSetEvent2_args_temp(ctx->decoder, &args);
8078 if (!args.commandBuffer) {
8079 vn_cs_decoder_set_fatal(ctx->decoder);
8080 return;
8081 }
8082
8083 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8084 ctx->dispatch_vkCmdSetEvent2(ctx, &args);
8085
8086
8087 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8088 vn_encode_vkCmdSetEvent2_reply(ctx->encoder, &args);
8089
8090 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8091 }
8092
vn_dispatch_vkCmdResetEvent2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8093 static inline void vn_dispatch_vkCmdResetEvent2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8094 {
8095 struct vn_command_vkCmdResetEvent2 args;
8096
8097 if (!ctx->dispatch_vkCmdResetEvent2) {
8098 vn_cs_decoder_set_fatal(ctx->decoder);
8099 return;
8100 }
8101
8102 vn_decode_vkCmdResetEvent2_args_temp(ctx->decoder, &args);
8103 if (!args.commandBuffer) {
8104 vn_cs_decoder_set_fatal(ctx->decoder);
8105 return;
8106 }
8107
8108 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8109 ctx->dispatch_vkCmdResetEvent2(ctx, &args);
8110
8111
8112 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8113 vn_encode_vkCmdResetEvent2_reply(ctx->encoder, &args);
8114
8115 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8116 }
8117
vn_dispatch_vkCmdWaitEvents2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8118 static inline void vn_dispatch_vkCmdWaitEvents2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8119 {
8120 struct vn_command_vkCmdWaitEvents2 args;
8121
8122 if (!ctx->dispatch_vkCmdWaitEvents2) {
8123 vn_cs_decoder_set_fatal(ctx->decoder);
8124 return;
8125 }
8126
8127 vn_decode_vkCmdWaitEvents2_args_temp(ctx->decoder, &args);
8128 if (!args.commandBuffer) {
8129 vn_cs_decoder_set_fatal(ctx->decoder);
8130 return;
8131 }
8132
8133 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8134 ctx->dispatch_vkCmdWaitEvents2(ctx, &args);
8135
8136
8137 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8138 vn_encode_vkCmdWaitEvents2_reply(ctx->encoder, &args);
8139
8140 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8141 }
8142
vn_dispatch_vkCmdPipelineBarrier2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8143 static inline void vn_dispatch_vkCmdPipelineBarrier2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8144 {
8145 struct vn_command_vkCmdPipelineBarrier2 args;
8146
8147 if (!ctx->dispatch_vkCmdPipelineBarrier2) {
8148 vn_cs_decoder_set_fatal(ctx->decoder);
8149 return;
8150 }
8151
8152 vn_decode_vkCmdPipelineBarrier2_args_temp(ctx->decoder, &args);
8153 if (!args.commandBuffer) {
8154 vn_cs_decoder_set_fatal(ctx->decoder);
8155 return;
8156 }
8157
8158 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8159 ctx->dispatch_vkCmdPipelineBarrier2(ctx, &args);
8160
8161
8162 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8163 vn_encode_vkCmdPipelineBarrier2_reply(ctx->encoder, &args);
8164
8165 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8166 }
8167
vn_dispatch_vkCmdWriteTimestamp2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8168 static inline void vn_dispatch_vkCmdWriteTimestamp2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8169 {
8170 struct vn_command_vkCmdWriteTimestamp2 args;
8171
8172 if (!ctx->dispatch_vkCmdWriteTimestamp2) {
8173 vn_cs_decoder_set_fatal(ctx->decoder);
8174 return;
8175 }
8176
8177 vn_decode_vkCmdWriteTimestamp2_args_temp(ctx->decoder, &args);
8178 if (!args.commandBuffer) {
8179 vn_cs_decoder_set_fatal(ctx->decoder);
8180 return;
8181 }
8182
8183 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8184 ctx->dispatch_vkCmdWriteTimestamp2(ctx, &args);
8185
8186
8187 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8188 vn_encode_vkCmdWriteTimestamp2_reply(ctx->encoder, &args);
8189
8190 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8191 }
8192
vn_dispatch_vkCmdBeginRendering(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8193 static inline void vn_dispatch_vkCmdBeginRendering(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8194 {
8195 struct vn_command_vkCmdBeginRendering args;
8196
8197 if (!ctx->dispatch_vkCmdBeginRendering) {
8198 vn_cs_decoder_set_fatal(ctx->decoder);
8199 return;
8200 }
8201
8202 vn_decode_vkCmdBeginRendering_args_temp(ctx->decoder, &args);
8203 if (!args.commandBuffer) {
8204 vn_cs_decoder_set_fatal(ctx->decoder);
8205 return;
8206 }
8207
8208 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8209 ctx->dispatch_vkCmdBeginRendering(ctx, &args);
8210
8211
8212 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8213 vn_encode_vkCmdBeginRendering_reply(ctx->encoder, &args);
8214
8215 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8216 }
8217
vn_dispatch_vkCmdEndRendering(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)8218 static inline void vn_dispatch_vkCmdEndRendering(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
8219 {
8220 struct vn_command_vkCmdEndRendering args;
8221
8222 if (!ctx->dispatch_vkCmdEndRendering) {
8223 vn_cs_decoder_set_fatal(ctx->decoder);
8224 return;
8225 }
8226
8227 vn_decode_vkCmdEndRendering_args_temp(ctx->decoder, &args);
8228 if (!args.commandBuffer) {
8229 vn_cs_decoder_set_fatal(ctx->decoder);
8230 return;
8231 }
8232
8233 if (!vn_cs_decoder_get_fatal(ctx->decoder))
8234 ctx->dispatch_vkCmdEndRendering(ctx, &args);
8235
8236
8237 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
8238 vn_encode_vkCmdEndRendering_reply(ctx->encoder, &args);
8239
8240 vn_cs_decoder_reset_temp_pool(ctx->decoder);
8241 }
8242
8243 #pragma GCC diagnostic pop
8244
8245 #endif /* VN_PROTOCOL_RENDERER_COMMAND_BUFFER_H */
8246