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_PIPELINE_H
9 #define VN_PROTOCOL_RENDERER_PIPELINE_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 /* struct VkSpecializationMapEntry */
18
19 static inline void
vn_decode_VkSpecializationMapEntry_temp(struct vn_cs_decoder * dec,VkSpecializationMapEntry * val)20 vn_decode_VkSpecializationMapEntry_temp(struct vn_cs_decoder *dec, VkSpecializationMapEntry *val)
21 {
22 vn_decode_uint32_t(dec, &val->constantID);
23 vn_decode_uint32_t(dec, &val->offset);
24 vn_decode_size_t(dec, &val->size);
25 }
26
27 static inline void
vn_replace_VkSpecializationMapEntry_handle(VkSpecializationMapEntry * val)28 vn_replace_VkSpecializationMapEntry_handle(VkSpecializationMapEntry *val)
29 {
30 /* skip val->constantID */
31 /* skip val->offset */
32 /* skip val->size */
33 }
34
35 /* struct VkSpecializationInfo */
36
37 static inline void
vn_decode_VkSpecializationInfo_temp(struct vn_cs_decoder * dec,VkSpecializationInfo * val)38 vn_decode_VkSpecializationInfo_temp(struct vn_cs_decoder *dec, VkSpecializationInfo *val)
39 {
40 vn_decode_uint32_t(dec, &val->mapEntryCount);
41 if (vn_peek_array_size(dec)) {
42 const uint32_t iter_count = vn_decode_array_size(dec, val->mapEntryCount);
43 val->pMapEntries = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pMapEntries) * iter_count);
44 if (!val->pMapEntries) return;
45 for (uint32_t i = 0; i < iter_count; i++)
46 vn_decode_VkSpecializationMapEntry_temp(dec, &((VkSpecializationMapEntry *)val->pMapEntries)[i]);
47 } else {
48 vn_decode_array_size(dec, val->mapEntryCount);
49 val->pMapEntries = NULL;
50 }
51 vn_decode_size_t(dec, &val->dataSize);
52 if (vn_peek_array_size(dec)) {
53 const size_t array_size = vn_decode_array_size(dec, val->dataSize);
54 val->pData = vn_cs_decoder_alloc_temp(dec, array_size);
55 if (!val->pData) return;
56 vn_decode_blob_array(dec, (void *)val->pData, array_size);
57 } else {
58 vn_decode_array_size(dec, val->dataSize);
59 val->pData = NULL;
60 }
61 }
62
63 static inline void
vn_replace_VkSpecializationInfo_handle(VkSpecializationInfo * val)64 vn_replace_VkSpecializationInfo_handle(VkSpecializationInfo *val)
65 {
66 /* skip val->mapEntryCount */
67 if (val->pMapEntries) {
68 for (uint32_t i = 0; i < val->mapEntryCount; i++)
69 vn_replace_VkSpecializationMapEntry_handle(&((VkSpecializationMapEntry *)val->pMapEntries)[i]);
70 }
71 /* skip val->dataSize */
72 /* skip val->pData */
73 }
74
75 /* struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo chain */
76
77 static inline void *
vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext_temp(struct vn_cs_decoder * dec)78 vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
79 {
80 /* no known/supported struct */
81 if (vn_decode_simple_pointer(dec))
82 vn_cs_decoder_set_fatal(dec);
83 return NULL;
84 }
85
86 static inline void
vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)87 vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
88 {
89 /* skip val->{sType,pNext} */
90 vn_decode_uint32_t(dec, &val->requiredSubgroupSize);
91 }
92
93 static inline void
vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)94 vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
95 {
96 VkStructureType stype;
97 vn_decode_VkStructureType(dec, &stype);
98 if (stype != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO)
99 vn_cs_decoder_set_fatal(dec);
100
101 val->sType = stype;
102 val->pNext = vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext_temp(dec);
103 vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self_temp(dec, val);
104 }
105
106 static inline void
vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle_self(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)107 vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle_self(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
108 {
109 /* skip val->sType */
110 /* skip val->pNext */
111 /* skip val->requiredSubgroupSize */
112 }
113
114 static inline void
vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)115 vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
116 {
117 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
118
119 do {
120 switch ((int32_t)pnext->sType) {
121 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
122 vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle_self((VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
123 break;
124 default:
125 /* ignore unknown/unsupported struct */
126 break;
127 }
128 pnext = pnext->pNext;
129 } while (pnext);
130 }
131
132 /* struct VkPipelineShaderStageCreateInfo chain */
133
134 static inline void *
vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(struct vn_cs_decoder * dec)135 vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
136 {
137 VkBaseOutStructure *pnext;
138 VkStructureType stype;
139
140 if (!vn_decode_simple_pointer(dec))
141 return NULL;
142
143 vn_decode_VkStructureType(dec, &stype);
144 switch ((int32_t)stype) {
145 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
146 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkShaderModuleCreateInfo));
147 if (pnext) {
148 pnext->sType = stype;
149 pnext->pNext = vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(dec);
150 vn_decode_VkShaderModuleCreateInfo_self_temp(dec, (VkShaderModuleCreateInfo *)pnext);
151 }
152 break;
153 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
154 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo));
155 if (pnext) {
156 pnext->sType = stype;
157 pnext->pNext = vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(dec);
158 vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self_temp(dec, (VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
159 }
160 break;
161 default:
162 /* unexpected struct */
163 pnext = NULL;
164 vn_cs_decoder_set_fatal(dec);
165 break;
166 }
167
168 return pnext;
169 }
170
171 static inline void
vn_decode_VkPipelineShaderStageCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineShaderStageCreateInfo * val)172 vn_decode_VkPipelineShaderStageCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateInfo *val)
173 {
174 /* skip val->{sType,pNext} */
175 vn_decode_VkFlags(dec, &val->flags);
176 vn_decode_VkShaderStageFlagBits(dec, &val->stage);
177 vn_decode_VkShaderModule_lookup(dec, &val->module);
178 if (vn_peek_array_size(dec)) {
179 const size_t string_size = vn_decode_array_size_unchecked(dec);
180 val->pName = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pName) * string_size);
181 if (!val->pName) return;
182 vn_decode_char_array(dec, (char *)val->pName, string_size);
183 } else {
184 vn_decode_array_size_unchecked(dec);
185 val->pName = NULL;
186 }
187 if (vn_decode_simple_pointer(dec)) {
188 val->pSpecializationInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pSpecializationInfo));
189 if (!val->pSpecializationInfo) return;
190 vn_decode_VkSpecializationInfo_temp(dec, (VkSpecializationInfo *)val->pSpecializationInfo);
191 } else {
192 val->pSpecializationInfo = NULL;
193 }
194 }
195
196 static inline void
vn_decode_VkPipelineShaderStageCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineShaderStageCreateInfo * val)197 vn_decode_VkPipelineShaderStageCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateInfo *val)
198 {
199 VkStructureType stype;
200 vn_decode_VkStructureType(dec, &stype);
201 if (stype != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
202 vn_cs_decoder_set_fatal(dec);
203
204 val->sType = stype;
205 val->pNext = vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(dec);
206 vn_decode_VkPipelineShaderStageCreateInfo_self_temp(dec, val);
207 }
208
209 static inline void
vn_replace_VkPipelineShaderStageCreateInfo_handle_self(VkPipelineShaderStageCreateInfo * val)210 vn_replace_VkPipelineShaderStageCreateInfo_handle_self(VkPipelineShaderStageCreateInfo *val)
211 {
212 /* skip val->sType */
213 /* skip val->pNext */
214 /* skip val->flags */
215 /* skip val->stage */
216 vn_replace_VkShaderModule_handle(&val->module);
217 /* skip val->pName */
218 if (val->pSpecializationInfo)
219 vn_replace_VkSpecializationInfo_handle((VkSpecializationInfo *)val->pSpecializationInfo);
220 }
221
222 static inline void
vn_replace_VkPipelineShaderStageCreateInfo_handle(VkPipelineShaderStageCreateInfo * val)223 vn_replace_VkPipelineShaderStageCreateInfo_handle(VkPipelineShaderStageCreateInfo *val)
224 {
225 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
226
227 do {
228 switch ((int32_t)pnext->sType) {
229 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
230 vn_replace_VkPipelineShaderStageCreateInfo_handle_self((VkPipelineShaderStageCreateInfo *)pnext);
231 break;
232 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
233 vn_replace_VkShaderModuleCreateInfo_handle_self((VkShaderModuleCreateInfo *)pnext);
234 break;
235 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
236 vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle_self((VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
237 break;
238 default:
239 /* ignore unknown/unsupported struct */
240 break;
241 }
242 pnext = pnext->pNext;
243 } while (pnext);
244 }
245
246 /* struct VkVertexInputBindingDescription */
247
248 static inline void
vn_decode_VkVertexInputBindingDescription_temp(struct vn_cs_decoder * dec,VkVertexInputBindingDescription * val)249 vn_decode_VkVertexInputBindingDescription_temp(struct vn_cs_decoder *dec, VkVertexInputBindingDescription *val)
250 {
251 vn_decode_uint32_t(dec, &val->binding);
252 vn_decode_uint32_t(dec, &val->stride);
253 vn_decode_VkVertexInputRate(dec, &val->inputRate);
254 }
255
256 static inline void
vn_replace_VkVertexInputBindingDescription_handle(VkVertexInputBindingDescription * val)257 vn_replace_VkVertexInputBindingDescription_handle(VkVertexInputBindingDescription *val)
258 {
259 /* skip val->binding */
260 /* skip val->stride */
261 /* skip val->inputRate */
262 }
263
264 /* struct VkVertexInputAttributeDescription */
265
266 static inline void
vn_decode_VkVertexInputAttributeDescription_temp(struct vn_cs_decoder * dec,VkVertexInputAttributeDescription * val)267 vn_decode_VkVertexInputAttributeDescription_temp(struct vn_cs_decoder *dec, VkVertexInputAttributeDescription *val)
268 {
269 vn_decode_uint32_t(dec, &val->location);
270 vn_decode_uint32_t(dec, &val->binding);
271 vn_decode_VkFormat(dec, &val->format);
272 vn_decode_uint32_t(dec, &val->offset);
273 }
274
275 static inline void
vn_replace_VkVertexInputAttributeDescription_handle(VkVertexInputAttributeDescription * val)276 vn_replace_VkVertexInputAttributeDescription_handle(VkVertexInputAttributeDescription *val)
277 {
278 /* skip val->location */
279 /* skip val->binding */
280 /* skip val->format */
281 /* skip val->offset */
282 }
283
284 /* struct VkVertexInputBindingDivisorDescriptionEXT */
285
286 static inline void
vn_decode_VkVertexInputBindingDivisorDescriptionEXT_temp(struct vn_cs_decoder * dec,VkVertexInputBindingDivisorDescriptionEXT * val)287 vn_decode_VkVertexInputBindingDivisorDescriptionEXT_temp(struct vn_cs_decoder *dec, VkVertexInputBindingDivisorDescriptionEXT *val)
288 {
289 vn_decode_uint32_t(dec, &val->binding);
290 vn_decode_uint32_t(dec, &val->divisor);
291 }
292
293 static inline void
vn_replace_VkVertexInputBindingDivisorDescriptionEXT_handle(VkVertexInputBindingDivisorDescriptionEXT * val)294 vn_replace_VkVertexInputBindingDivisorDescriptionEXT_handle(VkVertexInputBindingDivisorDescriptionEXT *val)
295 {
296 /* skip val->binding */
297 /* skip val->divisor */
298 }
299
300 /* struct VkPipelineVertexInputDivisorStateCreateInfoEXT chain */
301
302 static inline void *
vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)303 vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
304 {
305 /* no known/supported struct */
306 if (vn_decode_simple_pointer(dec))
307 vn_cs_decoder_set_fatal(dec);
308 return NULL;
309 }
310
311 static inline void
vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineVertexInputDivisorStateCreateInfoEXT * val)312 vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
313 {
314 /* skip val->{sType,pNext} */
315 vn_decode_uint32_t(dec, &val->vertexBindingDivisorCount);
316 if (vn_peek_array_size(dec)) {
317 const uint32_t iter_count = vn_decode_array_size(dec, val->vertexBindingDivisorCount);
318 val->pVertexBindingDivisors = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pVertexBindingDivisors) * iter_count);
319 if (!val->pVertexBindingDivisors) return;
320 for (uint32_t i = 0; i < iter_count; i++)
321 vn_decode_VkVertexInputBindingDivisorDescriptionEXT_temp(dec, &((VkVertexInputBindingDivisorDescriptionEXT *)val->pVertexBindingDivisors)[i]);
322 } else {
323 vn_decode_array_size(dec, val->vertexBindingDivisorCount);
324 val->pVertexBindingDivisors = NULL;
325 }
326 }
327
328 static inline void
vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineVertexInputDivisorStateCreateInfoEXT * val)329 vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
330 {
331 VkStructureType stype;
332 vn_decode_VkStructureType(dec, &stype);
333 if (stype != VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT)
334 vn_cs_decoder_set_fatal(dec);
335
336 val->sType = stype;
337 val->pNext = vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext_temp(dec);
338 vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self_temp(dec, val);
339 }
340
341 static inline void
vn_replace_VkPipelineVertexInputDivisorStateCreateInfoEXT_handle_self(VkPipelineVertexInputDivisorStateCreateInfoEXT * val)342 vn_replace_VkPipelineVertexInputDivisorStateCreateInfoEXT_handle_self(VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
343 {
344 /* skip val->sType */
345 /* skip val->pNext */
346 /* skip val->vertexBindingDivisorCount */
347 if (val->pVertexBindingDivisors) {
348 for (uint32_t i = 0; i < val->vertexBindingDivisorCount; i++)
349 vn_replace_VkVertexInputBindingDivisorDescriptionEXT_handle(&((VkVertexInputBindingDivisorDescriptionEXT *)val->pVertexBindingDivisors)[i]);
350 }
351 }
352
353 static inline void
vn_replace_VkPipelineVertexInputDivisorStateCreateInfoEXT_handle(VkPipelineVertexInputDivisorStateCreateInfoEXT * val)354 vn_replace_VkPipelineVertexInputDivisorStateCreateInfoEXT_handle(VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
355 {
356 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
357
358 do {
359 switch ((int32_t)pnext->sType) {
360 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
361 vn_replace_VkPipelineVertexInputDivisorStateCreateInfoEXT_handle_self((VkPipelineVertexInputDivisorStateCreateInfoEXT *)pnext);
362 break;
363 default:
364 /* ignore unknown/unsupported struct */
365 break;
366 }
367 pnext = pnext->pNext;
368 } while (pnext);
369 }
370
371 /* struct VkPipelineVertexInputStateCreateInfo chain */
372
373 static inline void *
vn_decode_VkPipelineVertexInputStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)374 vn_decode_VkPipelineVertexInputStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
375 {
376 VkBaseOutStructure *pnext;
377 VkStructureType stype;
378
379 if (!vn_decode_simple_pointer(dec))
380 return NULL;
381
382 vn_decode_VkStructureType(dec, &stype);
383 switch ((int32_t)stype) {
384 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
385 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT));
386 if (pnext) {
387 pnext->sType = stype;
388 pnext->pNext = vn_decode_VkPipelineVertexInputStateCreateInfo_pnext_temp(dec);
389 vn_decode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self_temp(dec, (VkPipelineVertexInputDivisorStateCreateInfoEXT *)pnext);
390 }
391 break;
392 default:
393 /* unexpected struct */
394 pnext = NULL;
395 vn_cs_decoder_set_fatal(dec);
396 break;
397 }
398
399 return pnext;
400 }
401
402 static inline void
vn_decode_VkPipelineVertexInputStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineVertexInputStateCreateInfo * val)403 vn_decode_VkPipelineVertexInputStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineVertexInputStateCreateInfo *val)
404 {
405 /* skip val->{sType,pNext} */
406 vn_decode_VkFlags(dec, &val->flags);
407 vn_decode_uint32_t(dec, &val->vertexBindingDescriptionCount);
408 if (vn_peek_array_size(dec)) {
409 const uint32_t iter_count = vn_decode_array_size(dec, val->vertexBindingDescriptionCount);
410 val->pVertexBindingDescriptions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pVertexBindingDescriptions) * iter_count);
411 if (!val->pVertexBindingDescriptions) return;
412 for (uint32_t i = 0; i < iter_count; i++)
413 vn_decode_VkVertexInputBindingDescription_temp(dec, &((VkVertexInputBindingDescription *)val->pVertexBindingDescriptions)[i]);
414 } else {
415 vn_decode_array_size(dec, val->vertexBindingDescriptionCount);
416 val->pVertexBindingDescriptions = NULL;
417 }
418 vn_decode_uint32_t(dec, &val->vertexAttributeDescriptionCount);
419 if (vn_peek_array_size(dec)) {
420 const uint32_t iter_count = vn_decode_array_size(dec, val->vertexAttributeDescriptionCount);
421 val->pVertexAttributeDescriptions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pVertexAttributeDescriptions) * iter_count);
422 if (!val->pVertexAttributeDescriptions) return;
423 for (uint32_t i = 0; i < iter_count; i++)
424 vn_decode_VkVertexInputAttributeDescription_temp(dec, &((VkVertexInputAttributeDescription *)val->pVertexAttributeDescriptions)[i]);
425 } else {
426 vn_decode_array_size(dec, val->vertexAttributeDescriptionCount);
427 val->pVertexAttributeDescriptions = NULL;
428 }
429 }
430
431 static inline void
vn_decode_VkPipelineVertexInputStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineVertexInputStateCreateInfo * val)432 vn_decode_VkPipelineVertexInputStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineVertexInputStateCreateInfo *val)
433 {
434 VkStructureType stype;
435 vn_decode_VkStructureType(dec, &stype);
436 if (stype != VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO)
437 vn_cs_decoder_set_fatal(dec);
438
439 val->sType = stype;
440 val->pNext = vn_decode_VkPipelineVertexInputStateCreateInfo_pnext_temp(dec);
441 vn_decode_VkPipelineVertexInputStateCreateInfo_self_temp(dec, val);
442 }
443
444 static inline void
vn_replace_VkPipelineVertexInputStateCreateInfo_handle_self(VkPipelineVertexInputStateCreateInfo * val)445 vn_replace_VkPipelineVertexInputStateCreateInfo_handle_self(VkPipelineVertexInputStateCreateInfo *val)
446 {
447 /* skip val->sType */
448 /* skip val->pNext */
449 /* skip val->flags */
450 /* skip val->vertexBindingDescriptionCount */
451 if (val->pVertexBindingDescriptions) {
452 for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
453 vn_replace_VkVertexInputBindingDescription_handle(&((VkVertexInputBindingDescription *)val->pVertexBindingDescriptions)[i]);
454 }
455 /* skip val->vertexAttributeDescriptionCount */
456 if (val->pVertexAttributeDescriptions) {
457 for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
458 vn_replace_VkVertexInputAttributeDescription_handle(&((VkVertexInputAttributeDescription *)val->pVertexAttributeDescriptions)[i]);
459 }
460 }
461
462 static inline void
vn_replace_VkPipelineVertexInputStateCreateInfo_handle(VkPipelineVertexInputStateCreateInfo * val)463 vn_replace_VkPipelineVertexInputStateCreateInfo_handle(VkPipelineVertexInputStateCreateInfo *val)
464 {
465 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
466
467 do {
468 switch ((int32_t)pnext->sType) {
469 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
470 vn_replace_VkPipelineVertexInputStateCreateInfo_handle_self((VkPipelineVertexInputStateCreateInfo *)pnext);
471 break;
472 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
473 vn_replace_VkPipelineVertexInputDivisorStateCreateInfoEXT_handle_self((VkPipelineVertexInputDivisorStateCreateInfoEXT *)pnext);
474 break;
475 default:
476 /* ignore unknown/unsupported struct */
477 break;
478 }
479 pnext = pnext->pNext;
480 } while (pnext);
481 }
482
483 /* struct VkPipelineInputAssemblyStateCreateInfo chain */
484
485 static inline void *
vn_decode_VkPipelineInputAssemblyStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)486 vn_decode_VkPipelineInputAssemblyStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
487 {
488 /* no known/supported struct */
489 if (vn_decode_simple_pointer(dec))
490 vn_cs_decoder_set_fatal(dec);
491 return NULL;
492 }
493
494 static inline void
vn_decode_VkPipelineInputAssemblyStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineInputAssemblyStateCreateInfo * val)495 vn_decode_VkPipelineInputAssemblyStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineInputAssemblyStateCreateInfo *val)
496 {
497 /* skip val->{sType,pNext} */
498 vn_decode_VkFlags(dec, &val->flags);
499 vn_decode_VkPrimitiveTopology(dec, &val->topology);
500 vn_decode_VkBool32(dec, &val->primitiveRestartEnable);
501 }
502
503 static inline void
vn_decode_VkPipelineInputAssemblyStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineInputAssemblyStateCreateInfo * val)504 vn_decode_VkPipelineInputAssemblyStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineInputAssemblyStateCreateInfo *val)
505 {
506 VkStructureType stype;
507 vn_decode_VkStructureType(dec, &stype);
508 if (stype != VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO)
509 vn_cs_decoder_set_fatal(dec);
510
511 val->sType = stype;
512 val->pNext = vn_decode_VkPipelineInputAssemblyStateCreateInfo_pnext_temp(dec);
513 vn_decode_VkPipelineInputAssemblyStateCreateInfo_self_temp(dec, val);
514 }
515
516 static inline void
vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle_self(VkPipelineInputAssemblyStateCreateInfo * val)517 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle_self(VkPipelineInputAssemblyStateCreateInfo *val)
518 {
519 /* skip val->sType */
520 /* skip val->pNext */
521 /* skip val->flags */
522 /* skip val->topology */
523 /* skip val->primitiveRestartEnable */
524 }
525
526 static inline void
vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle(VkPipelineInputAssemblyStateCreateInfo * val)527 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle(VkPipelineInputAssemblyStateCreateInfo *val)
528 {
529 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
530
531 do {
532 switch ((int32_t)pnext->sType) {
533 case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
534 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle_self((VkPipelineInputAssemblyStateCreateInfo *)pnext);
535 break;
536 default:
537 /* ignore unknown/unsupported struct */
538 break;
539 }
540 pnext = pnext->pNext;
541 } while (pnext);
542 }
543
544 /* struct VkPipelineTessellationDomainOriginStateCreateInfo chain */
545
546 static inline void *
vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)547 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
548 {
549 /* no known/supported struct */
550 if (vn_decode_simple_pointer(dec))
551 vn_cs_decoder_set_fatal(dec);
552 return NULL;
553 }
554
555 static inline void
vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineTessellationDomainOriginStateCreateInfo * val)556 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineTessellationDomainOriginStateCreateInfo *val)
557 {
558 /* skip val->{sType,pNext} */
559 vn_decode_VkTessellationDomainOrigin(dec, &val->domainOrigin);
560 }
561
562 static inline void
vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineTessellationDomainOriginStateCreateInfo * val)563 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineTessellationDomainOriginStateCreateInfo *val)
564 {
565 VkStructureType stype;
566 vn_decode_VkStructureType(dec, &stype);
567 if (stype != VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO)
568 vn_cs_decoder_set_fatal(dec);
569
570 val->sType = stype;
571 val->pNext = vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext_temp(dec);
572 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(dec, val);
573 }
574
575 static inline void
vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self(VkPipelineTessellationDomainOriginStateCreateInfo * val)576 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self(VkPipelineTessellationDomainOriginStateCreateInfo *val)
577 {
578 /* skip val->sType */
579 /* skip val->pNext */
580 /* skip val->domainOrigin */
581 }
582
583 static inline void
vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle(VkPipelineTessellationDomainOriginStateCreateInfo * val)584 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle(VkPipelineTessellationDomainOriginStateCreateInfo *val)
585 {
586 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
587
588 do {
589 switch ((int32_t)pnext->sType) {
590 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
591 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self((VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
592 break;
593 default:
594 /* ignore unknown/unsupported struct */
595 break;
596 }
597 pnext = pnext->pNext;
598 } while (pnext);
599 }
600
601 /* struct VkPipelineTessellationStateCreateInfo chain */
602
603 static inline void *
vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)604 vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
605 {
606 VkBaseOutStructure *pnext;
607 VkStructureType stype;
608
609 if (!vn_decode_simple_pointer(dec))
610 return NULL;
611
612 vn_decode_VkStructureType(dec, &stype);
613 switch ((int32_t)stype) {
614 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
615 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineTessellationDomainOriginStateCreateInfo));
616 if (pnext) {
617 pnext->sType = stype;
618 pnext->pNext = vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(dec);
619 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(dec, (VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
620 }
621 break;
622 default:
623 /* unexpected struct */
624 pnext = NULL;
625 vn_cs_decoder_set_fatal(dec);
626 break;
627 }
628
629 return pnext;
630 }
631
632 static inline void
vn_decode_VkPipelineTessellationStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineTessellationStateCreateInfo * val)633 vn_decode_VkPipelineTessellationStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineTessellationStateCreateInfo *val)
634 {
635 /* skip val->{sType,pNext} */
636 vn_decode_VkFlags(dec, &val->flags);
637 vn_decode_uint32_t(dec, &val->patchControlPoints);
638 }
639
640 static inline void
vn_decode_VkPipelineTessellationStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineTessellationStateCreateInfo * val)641 vn_decode_VkPipelineTessellationStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineTessellationStateCreateInfo *val)
642 {
643 VkStructureType stype;
644 vn_decode_VkStructureType(dec, &stype);
645 if (stype != VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO)
646 vn_cs_decoder_set_fatal(dec);
647
648 val->sType = stype;
649 val->pNext = vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(dec);
650 vn_decode_VkPipelineTessellationStateCreateInfo_self_temp(dec, val);
651 }
652
653 static inline void
vn_replace_VkPipelineTessellationStateCreateInfo_handle_self(VkPipelineTessellationStateCreateInfo * val)654 vn_replace_VkPipelineTessellationStateCreateInfo_handle_self(VkPipelineTessellationStateCreateInfo *val)
655 {
656 /* skip val->sType */
657 /* skip val->pNext */
658 /* skip val->flags */
659 /* skip val->patchControlPoints */
660 }
661
662 static inline void
vn_replace_VkPipelineTessellationStateCreateInfo_handle(VkPipelineTessellationStateCreateInfo * val)663 vn_replace_VkPipelineTessellationStateCreateInfo_handle(VkPipelineTessellationStateCreateInfo *val)
664 {
665 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
666
667 do {
668 switch ((int32_t)pnext->sType) {
669 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
670 vn_replace_VkPipelineTessellationStateCreateInfo_handle_self((VkPipelineTessellationStateCreateInfo *)pnext);
671 break;
672 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
673 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self((VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
674 break;
675 default:
676 /* ignore unknown/unsupported struct */
677 break;
678 }
679 pnext = pnext->pNext;
680 } while (pnext);
681 }
682
683 /* struct VkPipelineViewportDepthClipControlCreateInfoEXT chain */
684
685 static inline void *
vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)686 vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
687 {
688 /* no known/supported struct */
689 if (vn_decode_simple_pointer(dec))
690 vn_cs_decoder_set_fatal(dec);
691 return NULL;
692 }
693
694 static inline void
vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineViewportDepthClipControlCreateInfoEXT * val)695 vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineViewportDepthClipControlCreateInfoEXT *val)
696 {
697 /* skip val->{sType,pNext} */
698 vn_decode_VkBool32(dec, &val->negativeOneToOne);
699 }
700
701 static inline void
vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineViewportDepthClipControlCreateInfoEXT * val)702 vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineViewportDepthClipControlCreateInfoEXT *val)
703 {
704 VkStructureType stype;
705 vn_decode_VkStructureType(dec, &stype);
706 if (stype != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT)
707 vn_cs_decoder_set_fatal(dec);
708
709 val->sType = stype;
710 val->pNext = vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext_temp(dec);
711 vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_self_temp(dec, val);
712 }
713
714 static inline void
vn_replace_VkPipelineViewportDepthClipControlCreateInfoEXT_handle_self(VkPipelineViewportDepthClipControlCreateInfoEXT * val)715 vn_replace_VkPipelineViewportDepthClipControlCreateInfoEXT_handle_self(VkPipelineViewportDepthClipControlCreateInfoEXT *val)
716 {
717 /* skip val->sType */
718 /* skip val->pNext */
719 /* skip val->negativeOneToOne */
720 }
721
722 static inline void
vn_replace_VkPipelineViewportDepthClipControlCreateInfoEXT_handle(VkPipelineViewportDepthClipControlCreateInfoEXT * val)723 vn_replace_VkPipelineViewportDepthClipControlCreateInfoEXT_handle(VkPipelineViewportDepthClipControlCreateInfoEXT *val)
724 {
725 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
726
727 do {
728 switch ((int32_t)pnext->sType) {
729 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
730 vn_replace_VkPipelineViewportDepthClipControlCreateInfoEXT_handle_self((VkPipelineViewportDepthClipControlCreateInfoEXT *)pnext);
731 break;
732 default:
733 /* ignore unknown/unsupported struct */
734 break;
735 }
736 pnext = pnext->pNext;
737 } while (pnext);
738 }
739
740 /* struct VkPipelineViewportStateCreateInfo chain */
741
742 static inline void *
vn_decode_VkPipelineViewportStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)743 vn_decode_VkPipelineViewportStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
744 {
745 VkBaseOutStructure *pnext;
746 VkStructureType stype;
747
748 if (!vn_decode_simple_pointer(dec))
749 return NULL;
750
751 vn_decode_VkStructureType(dec, &stype);
752 switch ((int32_t)stype) {
753 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
754 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT));
755 if (pnext) {
756 pnext->sType = stype;
757 pnext->pNext = vn_decode_VkPipelineViewportStateCreateInfo_pnext_temp(dec);
758 vn_decode_VkPipelineViewportDepthClipControlCreateInfoEXT_self_temp(dec, (VkPipelineViewportDepthClipControlCreateInfoEXT *)pnext);
759 }
760 break;
761 default:
762 /* unexpected struct */
763 pnext = NULL;
764 vn_cs_decoder_set_fatal(dec);
765 break;
766 }
767
768 return pnext;
769 }
770
771 static inline void
vn_decode_VkPipelineViewportStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineViewportStateCreateInfo * val)772 vn_decode_VkPipelineViewportStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineViewportStateCreateInfo *val)
773 {
774 /* skip val->{sType,pNext} */
775 vn_decode_VkFlags(dec, &val->flags);
776 vn_decode_uint32_t(dec, &val->viewportCount);
777 if (vn_peek_array_size(dec)) {
778 const uint32_t iter_count = vn_decode_array_size(dec, val->viewportCount);
779 val->pViewports = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pViewports) * iter_count);
780 if (!val->pViewports) return;
781 for (uint32_t i = 0; i < iter_count; i++)
782 vn_decode_VkViewport_temp(dec, &((VkViewport *)val->pViewports)[i]);
783 } else {
784 vn_decode_array_size_unchecked(dec);
785 val->pViewports = NULL;
786 }
787 vn_decode_uint32_t(dec, &val->scissorCount);
788 if (vn_peek_array_size(dec)) {
789 const uint32_t iter_count = vn_decode_array_size(dec, val->scissorCount);
790 val->pScissors = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pScissors) * iter_count);
791 if (!val->pScissors) return;
792 for (uint32_t i = 0; i < iter_count; i++)
793 vn_decode_VkRect2D_temp(dec, &((VkRect2D *)val->pScissors)[i]);
794 } else {
795 vn_decode_array_size_unchecked(dec);
796 val->pScissors = NULL;
797 }
798 }
799
800 static inline void
vn_decode_VkPipelineViewportStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineViewportStateCreateInfo * val)801 vn_decode_VkPipelineViewportStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineViewportStateCreateInfo *val)
802 {
803 VkStructureType stype;
804 vn_decode_VkStructureType(dec, &stype);
805 if (stype != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO)
806 vn_cs_decoder_set_fatal(dec);
807
808 val->sType = stype;
809 val->pNext = vn_decode_VkPipelineViewportStateCreateInfo_pnext_temp(dec);
810 vn_decode_VkPipelineViewportStateCreateInfo_self_temp(dec, val);
811 }
812
813 static inline void
vn_replace_VkPipelineViewportStateCreateInfo_handle_self(VkPipelineViewportStateCreateInfo * val)814 vn_replace_VkPipelineViewportStateCreateInfo_handle_self(VkPipelineViewportStateCreateInfo *val)
815 {
816 /* skip val->sType */
817 /* skip val->pNext */
818 /* skip val->flags */
819 /* skip val->viewportCount */
820 if (val->pViewports) {
821 for (uint32_t i = 0; i < val->viewportCount; i++)
822 vn_replace_VkViewport_handle(&((VkViewport *)val->pViewports)[i]);
823 }
824 /* skip val->scissorCount */
825 if (val->pScissors) {
826 for (uint32_t i = 0; i < val->scissorCount; i++)
827 vn_replace_VkRect2D_handle(&((VkRect2D *)val->pScissors)[i]);
828 }
829 }
830
831 static inline void
vn_replace_VkPipelineViewportStateCreateInfo_handle(VkPipelineViewportStateCreateInfo * val)832 vn_replace_VkPipelineViewportStateCreateInfo_handle(VkPipelineViewportStateCreateInfo *val)
833 {
834 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
835
836 do {
837 switch ((int32_t)pnext->sType) {
838 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
839 vn_replace_VkPipelineViewportStateCreateInfo_handle_self((VkPipelineViewportStateCreateInfo *)pnext);
840 break;
841 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
842 vn_replace_VkPipelineViewportDepthClipControlCreateInfoEXT_handle_self((VkPipelineViewportDepthClipControlCreateInfoEXT *)pnext);
843 break;
844 default:
845 /* ignore unknown/unsupported struct */
846 break;
847 }
848 pnext = pnext->pNext;
849 } while (pnext);
850 }
851
852 /* struct VkPipelineRasterizationConservativeStateCreateInfoEXT chain */
853
854 static inline void *
vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)855 vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
856 {
857 /* no known/supported struct */
858 if (vn_decode_simple_pointer(dec))
859 vn_cs_decoder_set_fatal(dec);
860 return NULL;
861 }
862
863 static inline void
vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationConservativeStateCreateInfoEXT * val)864 vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
865 {
866 /* skip val->{sType,pNext} */
867 vn_decode_VkFlags(dec, &val->flags);
868 vn_decode_VkConservativeRasterizationModeEXT(dec, &val->conservativeRasterizationMode);
869 vn_decode_float(dec, &val->extraPrimitiveOverestimationSize);
870 }
871
872 static inline void
vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationConservativeStateCreateInfoEXT * val)873 vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
874 {
875 VkStructureType stype;
876 vn_decode_VkStructureType(dec, &stype);
877 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT)
878 vn_cs_decoder_set_fatal(dec);
879
880 val->sType = stype;
881 val->pNext = vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext_temp(dec);
882 vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self_temp(dec, val);
883 }
884
885 static inline void
vn_replace_VkPipelineRasterizationConservativeStateCreateInfoEXT_handle_self(VkPipelineRasterizationConservativeStateCreateInfoEXT * val)886 vn_replace_VkPipelineRasterizationConservativeStateCreateInfoEXT_handle_self(VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
887 {
888 /* skip val->sType */
889 /* skip val->pNext */
890 /* skip val->flags */
891 /* skip val->conservativeRasterizationMode */
892 /* skip val->extraPrimitiveOverestimationSize */
893 }
894
895 static inline void
vn_replace_VkPipelineRasterizationConservativeStateCreateInfoEXT_handle(VkPipelineRasterizationConservativeStateCreateInfoEXT * val)896 vn_replace_VkPipelineRasterizationConservativeStateCreateInfoEXT_handle(VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
897 {
898 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
899
900 do {
901 switch ((int32_t)pnext->sType) {
902 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
903 vn_replace_VkPipelineRasterizationConservativeStateCreateInfoEXT_handle_self((VkPipelineRasterizationConservativeStateCreateInfoEXT *)pnext);
904 break;
905 default:
906 /* ignore unknown/unsupported struct */
907 break;
908 }
909 pnext = pnext->pNext;
910 } while (pnext);
911 }
912
913 /* struct VkPipelineRasterizationStateStreamCreateInfoEXT chain */
914
915 static inline void *
vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)916 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
917 {
918 /* no known/supported struct */
919 if (vn_decode_simple_pointer(dec))
920 vn_cs_decoder_set_fatal(dec);
921 return NULL;
922 }
923
924 static inline void
vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateStreamCreateInfoEXT * val)925 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateStreamCreateInfoEXT *val)
926 {
927 /* skip val->{sType,pNext} */
928 vn_decode_VkFlags(dec, &val->flags);
929 vn_decode_uint32_t(dec, &val->rasterizationStream);
930 }
931
932 static inline void
vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateStreamCreateInfoEXT * val)933 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateStreamCreateInfoEXT *val)
934 {
935 VkStructureType stype;
936 vn_decode_VkStructureType(dec, &stype);
937 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT)
938 vn_cs_decoder_set_fatal(dec);
939
940 val->sType = stype;
941 val->pNext = vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext_temp(dec);
942 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(dec, val);
943 }
944
945 static inline void
vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self(VkPipelineRasterizationStateStreamCreateInfoEXT * val)946 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self(VkPipelineRasterizationStateStreamCreateInfoEXT *val)
947 {
948 /* skip val->sType */
949 /* skip val->pNext */
950 /* skip val->flags */
951 /* skip val->rasterizationStream */
952 }
953
954 static inline void
vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle(VkPipelineRasterizationStateStreamCreateInfoEXT * val)955 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle(VkPipelineRasterizationStateStreamCreateInfoEXT *val)
956 {
957 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
958
959 do {
960 switch ((int32_t)pnext->sType) {
961 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
962 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self((VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
963 break;
964 default:
965 /* ignore unknown/unsupported struct */
966 break;
967 }
968 pnext = pnext->pNext;
969 } while (pnext);
970 }
971
972 /* struct VkPipelineRasterizationDepthClipStateCreateInfoEXT chain */
973
974 static inline void *
vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)975 vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
976 {
977 /* no known/supported struct */
978 if (vn_decode_simple_pointer(dec))
979 vn_cs_decoder_set_fatal(dec);
980 return NULL;
981 }
982
983 static inline void
vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)984 vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
985 {
986 /* skip val->{sType,pNext} */
987 vn_decode_VkFlags(dec, &val->flags);
988 vn_decode_VkBool32(dec, &val->depthClipEnable);
989 }
990
991 static inline void
vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)992 vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
993 {
994 VkStructureType stype;
995 vn_decode_VkStructureType(dec, &stype);
996 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT)
997 vn_cs_decoder_set_fatal(dec);
998
999 val->sType = stype;
1000 val->pNext = vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext_temp(dec);
1001 vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self_temp(dec, val);
1002 }
1003
1004 static inline void
vn_replace_VkPipelineRasterizationDepthClipStateCreateInfoEXT_handle_self(VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)1005 vn_replace_VkPipelineRasterizationDepthClipStateCreateInfoEXT_handle_self(VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
1006 {
1007 /* skip val->sType */
1008 /* skip val->pNext */
1009 /* skip val->flags */
1010 /* skip val->depthClipEnable */
1011 }
1012
1013 static inline void
vn_replace_VkPipelineRasterizationDepthClipStateCreateInfoEXT_handle(VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)1014 vn_replace_VkPipelineRasterizationDepthClipStateCreateInfoEXT_handle(VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
1015 {
1016 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1017
1018 do {
1019 switch ((int32_t)pnext->sType) {
1020 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
1021 vn_replace_VkPipelineRasterizationDepthClipStateCreateInfoEXT_handle_self((VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pnext);
1022 break;
1023 default:
1024 /* ignore unknown/unsupported struct */
1025 break;
1026 }
1027 pnext = pnext->pNext;
1028 } while (pnext);
1029 }
1030
1031 /* struct VkPipelineRasterizationLineStateCreateInfoEXT chain */
1032
1033 static inline void *
vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)1034 vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
1035 {
1036 /* no known/supported struct */
1037 if (vn_decode_simple_pointer(dec))
1038 vn_cs_decoder_set_fatal(dec);
1039 return NULL;
1040 }
1041
1042 static inline void
vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationLineStateCreateInfoEXT * val)1043 vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationLineStateCreateInfoEXT *val)
1044 {
1045 /* skip val->{sType,pNext} */
1046 vn_decode_VkLineRasterizationModeEXT(dec, &val->lineRasterizationMode);
1047 vn_decode_VkBool32(dec, &val->stippledLineEnable);
1048 vn_decode_uint32_t(dec, &val->lineStippleFactor);
1049 vn_decode_uint16_t(dec, &val->lineStipplePattern);
1050 }
1051
1052 static inline void
vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationLineStateCreateInfoEXT * val)1053 vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationLineStateCreateInfoEXT *val)
1054 {
1055 VkStructureType stype;
1056 vn_decode_VkStructureType(dec, &stype);
1057 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT)
1058 vn_cs_decoder_set_fatal(dec);
1059
1060 val->sType = stype;
1061 val->pNext = vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext_temp(dec);
1062 vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_self_temp(dec, val);
1063 }
1064
1065 static inline void
vn_replace_VkPipelineRasterizationLineStateCreateInfoEXT_handle_self(VkPipelineRasterizationLineStateCreateInfoEXT * val)1066 vn_replace_VkPipelineRasterizationLineStateCreateInfoEXT_handle_self(VkPipelineRasterizationLineStateCreateInfoEXT *val)
1067 {
1068 /* skip val->sType */
1069 /* skip val->pNext */
1070 /* skip val->lineRasterizationMode */
1071 /* skip val->stippledLineEnable */
1072 /* skip val->lineStippleFactor */
1073 /* skip val->lineStipplePattern */
1074 }
1075
1076 static inline void
vn_replace_VkPipelineRasterizationLineStateCreateInfoEXT_handle(VkPipelineRasterizationLineStateCreateInfoEXT * val)1077 vn_replace_VkPipelineRasterizationLineStateCreateInfoEXT_handle(VkPipelineRasterizationLineStateCreateInfoEXT *val)
1078 {
1079 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1080
1081 do {
1082 switch ((int32_t)pnext->sType) {
1083 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
1084 vn_replace_VkPipelineRasterizationLineStateCreateInfoEXT_handle_self((VkPipelineRasterizationLineStateCreateInfoEXT *)pnext);
1085 break;
1086 default:
1087 /* ignore unknown/unsupported struct */
1088 break;
1089 }
1090 pnext = pnext->pNext;
1091 } while (pnext);
1092 }
1093
1094 /* struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT chain */
1095
1096 static inline void *
vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)1097 vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
1098 {
1099 /* no known/supported struct */
1100 if (vn_decode_simple_pointer(dec))
1101 vn_cs_decoder_set_fatal(dec);
1102 return NULL;
1103 }
1104
1105 static inline void
vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1106 vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1107 {
1108 /* skip val->{sType,pNext} */
1109 vn_decode_VkProvokingVertexModeEXT(dec, &val->provokingVertexMode);
1110 }
1111
1112 static inline void
vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1113 vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1114 {
1115 VkStructureType stype;
1116 vn_decode_VkStructureType(dec, &stype);
1117 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT)
1118 vn_cs_decoder_set_fatal(dec);
1119
1120 val->sType = stype;
1121 val->pNext = vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext_temp(dec);
1122 vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self_temp(dec, val);
1123 }
1124
1125 static inline void
vn_replace_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_handle_self(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1126 vn_replace_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_handle_self(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1127 {
1128 /* skip val->sType */
1129 /* skip val->pNext */
1130 /* skip val->provokingVertexMode */
1131 }
1132
1133 static inline void
vn_replace_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_handle(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1134 vn_replace_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_handle(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1135 {
1136 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1137
1138 do {
1139 switch ((int32_t)pnext->sType) {
1140 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
1141 vn_replace_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_handle_self((VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)pnext);
1142 break;
1143 default:
1144 /* ignore unknown/unsupported struct */
1145 break;
1146 }
1147 pnext = pnext->pNext;
1148 } while (pnext);
1149 }
1150
1151 /* struct VkPipelineRasterizationStateCreateInfo chain */
1152
1153 static inline void *
vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1154 vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1155 {
1156 VkBaseOutStructure *pnext;
1157 VkStructureType stype;
1158
1159 if (!vn_decode_simple_pointer(dec))
1160 return NULL;
1161
1162 vn_decode_VkStructureType(dec, &stype);
1163 switch ((int32_t)stype) {
1164 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
1165 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT));
1166 if (pnext) {
1167 pnext->sType = stype;
1168 pnext->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
1169 vn_decode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self_temp(dec, (VkPipelineRasterizationConservativeStateCreateInfoEXT *)pnext);
1170 }
1171 break;
1172 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
1173 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT));
1174 if (pnext) {
1175 pnext->sType = stype;
1176 pnext->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
1177 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(dec, (VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
1178 }
1179 break;
1180 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
1181 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT));
1182 if (pnext) {
1183 pnext->sType = stype;
1184 pnext->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
1185 vn_decode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self_temp(dec, (VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pnext);
1186 }
1187 break;
1188 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
1189 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRasterizationLineStateCreateInfoEXT));
1190 if (pnext) {
1191 pnext->sType = stype;
1192 pnext->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
1193 vn_decode_VkPipelineRasterizationLineStateCreateInfoEXT_self_temp(dec, (VkPipelineRasterizationLineStateCreateInfoEXT *)pnext);
1194 }
1195 break;
1196 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
1197 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT));
1198 if (pnext) {
1199 pnext->sType = stype;
1200 pnext->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
1201 vn_decode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self_temp(dec, (VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)pnext);
1202 }
1203 break;
1204 default:
1205 /* unexpected struct */
1206 pnext = NULL;
1207 vn_cs_decoder_set_fatal(dec);
1208 break;
1209 }
1210
1211 return pnext;
1212 }
1213
1214 static inline void
vn_decode_VkPipelineRasterizationStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateCreateInfo * val)1215 vn_decode_VkPipelineRasterizationStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateCreateInfo *val)
1216 {
1217 /* skip val->{sType,pNext} */
1218 vn_decode_VkFlags(dec, &val->flags);
1219 vn_decode_VkBool32(dec, &val->depthClampEnable);
1220 vn_decode_VkBool32(dec, &val->rasterizerDiscardEnable);
1221 vn_decode_VkPolygonMode(dec, &val->polygonMode);
1222 vn_decode_VkFlags(dec, &val->cullMode);
1223 vn_decode_VkFrontFace(dec, &val->frontFace);
1224 vn_decode_VkBool32(dec, &val->depthBiasEnable);
1225 vn_decode_float(dec, &val->depthBiasConstantFactor);
1226 vn_decode_float(dec, &val->depthBiasClamp);
1227 vn_decode_float(dec, &val->depthBiasSlopeFactor);
1228 vn_decode_float(dec, &val->lineWidth);
1229 }
1230
1231 static inline void
vn_decode_VkPipelineRasterizationStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateCreateInfo * val)1232 vn_decode_VkPipelineRasterizationStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateCreateInfo *val)
1233 {
1234 VkStructureType stype;
1235 vn_decode_VkStructureType(dec, &stype);
1236 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO)
1237 vn_cs_decoder_set_fatal(dec);
1238
1239 val->sType = stype;
1240 val->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
1241 vn_decode_VkPipelineRasterizationStateCreateInfo_self_temp(dec, val);
1242 }
1243
1244 static inline void
vn_replace_VkPipelineRasterizationStateCreateInfo_handle_self(VkPipelineRasterizationStateCreateInfo * val)1245 vn_replace_VkPipelineRasterizationStateCreateInfo_handle_self(VkPipelineRasterizationStateCreateInfo *val)
1246 {
1247 /* skip val->sType */
1248 /* skip val->pNext */
1249 /* skip val->flags */
1250 /* skip val->depthClampEnable */
1251 /* skip val->rasterizerDiscardEnable */
1252 /* skip val->polygonMode */
1253 /* skip val->cullMode */
1254 /* skip val->frontFace */
1255 /* skip val->depthBiasEnable */
1256 /* skip val->depthBiasConstantFactor */
1257 /* skip val->depthBiasClamp */
1258 /* skip val->depthBiasSlopeFactor */
1259 /* skip val->lineWidth */
1260 }
1261
1262 static inline void
vn_replace_VkPipelineRasterizationStateCreateInfo_handle(VkPipelineRasterizationStateCreateInfo * val)1263 vn_replace_VkPipelineRasterizationStateCreateInfo_handle(VkPipelineRasterizationStateCreateInfo *val)
1264 {
1265 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1266
1267 do {
1268 switch ((int32_t)pnext->sType) {
1269 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
1270 vn_replace_VkPipelineRasterizationStateCreateInfo_handle_self((VkPipelineRasterizationStateCreateInfo *)pnext);
1271 break;
1272 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
1273 vn_replace_VkPipelineRasterizationConservativeStateCreateInfoEXT_handle_self((VkPipelineRasterizationConservativeStateCreateInfoEXT *)pnext);
1274 break;
1275 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
1276 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self((VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
1277 break;
1278 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
1279 vn_replace_VkPipelineRasterizationDepthClipStateCreateInfoEXT_handle_self((VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pnext);
1280 break;
1281 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
1282 vn_replace_VkPipelineRasterizationLineStateCreateInfoEXT_handle_self((VkPipelineRasterizationLineStateCreateInfoEXT *)pnext);
1283 break;
1284 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
1285 vn_replace_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_handle_self((VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)pnext);
1286 break;
1287 default:
1288 /* ignore unknown/unsupported struct */
1289 break;
1290 }
1291 pnext = pnext->pNext;
1292 } while (pnext);
1293 }
1294
1295 /* struct VkPipelineMultisampleStateCreateInfo chain */
1296
1297 static inline void *
vn_decode_VkPipelineMultisampleStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1298 vn_decode_VkPipelineMultisampleStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1299 {
1300 /* no known/supported struct */
1301 if (vn_decode_simple_pointer(dec))
1302 vn_cs_decoder_set_fatal(dec);
1303 return NULL;
1304 }
1305
1306 static inline void
vn_decode_VkPipelineMultisampleStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineMultisampleStateCreateInfo * val)1307 vn_decode_VkPipelineMultisampleStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineMultisampleStateCreateInfo *val)
1308 {
1309 /* skip val->{sType,pNext} */
1310 vn_decode_VkFlags(dec, &val->flags);
1311 vn_decode_VkSampleCountFlagBits(dec, &val->rasterizationSamples);
1312 vn_decode_VkBool32(dec, &val->sampleShadingEnable);
1313 vn_decode_float(dec, &val->minSampleShading);
1314 if (vn_peek_array_size(dec)) {
1315 const size_t array_size = vn_decode_array_size(dec, (val->rasterizationSamples + 31) / 32);
1316 val->pSampleMask = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pSampleMask) * array_size);
1317 if (!val->pSampleMask) return;
1318 vn_decode_VkSampleMask_array(dec, (VkSampleMask *)val->pSampleMask, array_size);
1319 } else {
1320 vn_decode_array_size_unchecked(dec);
1321 val->pSampleMask = NULL;
1322 }
1323 vn_decode_VkBool32(dec, &val->alphaToCoverageEnable);
1324 vn_decode_VkBool32(dec, &val->alphaToOneEnable);
1325 }
1326
1327 static inline void
vn_decode_VkPipelineMultisampleStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineMultisampleStateCreateInfo * val)1328 vn_decode_VkPipelineMultisampleStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineMultisampleStateCreateInfo *val)
1329 {
1330 VkStructureType stype;
1331 vn_decode_VkStructureType(dec, &stype);
1332 if (stype != VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO)
1333 vn_cs_decoder_set_fatal(dec);
1334
1335 val->sType = stype;
1336 val->pNext = vn_decode_VkPipelineMultisampleStateCreateInfo_pnext_temp(dec);
1337 vn_decode_VkPipelineMultisampleStateCreateInfo_self_temp(dec, val);
1338 }
1339
1340 static inline void
vn_replace_VkPipelineMultisampleStateCreateInfo_handle_self(VkPipelineMultisampleStateCreateInfo * val)1341 vn_replace_VkPipelineMultisampleStateCreateInfo_handle_self(VkPipelineMultisampleStateCreateInfo *val)
1342 {
1343 /* skip val->sType */
1344 /* skip val->pNext */
1345 /* skip val->flags */
1346 /* skip val->rasterizationSamples */
1347 /* skip val->sampleShadingEnable */
1348 /* skip val->minSampleShading */
1349 /* skip val->pSampleMask */
1350 /* skip val->alphaToCoverageEnable */
1351 /* skip val->alphaToOneEnable */
1352 }
1353
1354 static inline void
vn_replace_VkPipelineMultisampleStateCreateInfo_handle(VkPipelineMultisampleStateCreateInfo * val)1355 vn_replace_VkPipelineMultisampleStateCreateInfo_handle(VkPipelineMultisampleStateCreateInfo *val)
1356 {
1357 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1358
1359 do {
1360 switch ((int32_t)pnext->sType) {
1361 case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
1362 vn_replace_VkPipelineMultisampleStateCreateInfo_handle_self((VkPipelineMultisampleStateCreateInfo *)pnext);
1363 break;
1364 default:
1365 /* ignore unknown/unsupported struct */
1366 break;
1367 }
1368 pnext = pnext->pNext;
1369 } while (pnext);
1370 }
1371
1372 /* struct VkStencilOpState */
1373
1374 static inline void
vn_decode_VkStencilOpState_temp(struct vn_cs_decoder * dec,VkStencilOpState * val)1375 vn_decode_VkStencilOpState_temp(struct vn_cs_decoder *dec, VkStencilOpState *val)
1376 {
1377 vn_decode_VkStencilOp(dec, &val->failOp);
1378 vn_decode_VkStencilOp(dec, &val->passOp);
1379 vn_decode_VkStencilOp(dec, &val->depthFailOp);
1380 vn_decode_VkCompareOp(dec, &val->compareOp);
1381 vn_decode_uint32_t(dec, &val->compareMask);
1382 vn_decode_uint32_t(dec, &val->writeMask);
1383 vn_decode_uint32_t(dec, &val->reference);
1384 }
1385
1386 static inline void
vn_replace_VkStencilOpState_handle(VkStencilOpState * val)1387 vn_replace_VkStencilOpState_handle(VkStencilOpState *val)
1388 {
1389 /* skip val->failOp */
1390 /* skip val->passOp */
1391 /* skip val->depthFailOp */
1392 /* skip val->compareOp */
1393 /* skip val->compareMask */
1394 /* skip val->writeMask */
1395 /* skip val->reference */
1396 }
1397
1398 /* struct VkPipelineDepthStencilStateCreateInfo chain */
1399
1400 static inline void *
vn_decode_VkPipelineDepthStencilStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1401 vn_decode_VkPipelineDepthStencilStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1402 {
1403 /* no known/supported struct */
1404 if (vn_decode_simple_pointer(dec))
1405 vn_cs_decoder_set_fatal(dec);
1406 return NULL;
1407 }
1408
1409 static inline void
vn_decode_VkPipelineDepthStencilStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineDepthStencilStateCreateInfo * val)1410 vn_decode_VkPipelineDepthStencilStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateInfo *val)
1411 {
1412 /* skip val->{sType,pNext} */
1413 vn_decode_VkFlags(dec, &val->flags);
1414 vn_decode_VkBool32(dec, &val->depthTestEnable);
1415 vn_decode_VkBool32(dec, &val->depthWriteEnable);
1416 vn_decode_VkCompareOp(dec, &val->depthCompareOp);
1417 vn_decode_VkBool32(dec, &val->depthBoundsTestEnable);
1418 vn_decode_VkBool32(dec, &val->stencilTestEnable);
1419 vn_decode_VkStencilOpState_temp(dec, &val->front);
1420 vn_decode_VkStencilOpState_temp(dec, &val->back);
1421 vn_decode_float(dec, &val->minDepthBounds);
1422 vn_decode_float(dec, &val->maxDepthBounds);
1423 }
1424
1425 static inline void
vn_decode_VkPipelineDepthStencilStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineDepthStencilStateCreateInfo * val)1426 vn_decode_VkPipelineDepthStencilStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateInfo *val)
1427 {
1428 VkStructureType stype;
1429 vn_decode_VkStructureType(dec, &stype);
1430 if (stype != VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO)
1431 vn_cs_decoder_set_fatal(dec);
1432
1433 val->sType = stype;
1434 val->pNext = vn_decode_VkPipelineDepthStencilStateCreateInfo_pnext_temp(dec);
1435 vn_decode_VkPipelineDepthStencilStateCreateInfo_self_temp(dec, val);
1436 }
1437
1438 static inline void
vn_replace_VkPipelineDepthStencilStateCreateInfo_handle_self(VkPipelineDepthStencilStateCreateInfo * val)1439 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle_self(VkPipelineDepthStencilStateCreateInfo *val)
1440 {
1441 /* skip val->sType */
1442 /* skip val->pNext */
1443 /* skip val->flags */
1444 /* skip val->depthTestEnable */
1445 /* skip val->depthWriteEnable */
1446 /* skip val->depthCompareOp */
1447 /* skip val->depthBoundsTestEnable */
1448 /* skip val->stencilTestEnable */
1449 vn_replace_VkStencilOpState_handle(&val->front);
1450 vn_replace_VkStencilOpState_handle(&val->back);
1451 /* skip val->minDepthBounds */
1452 /* skip val->maxDepthBounds */
1453 }
1454
1455 static inline void
vn_replace_VkPipelineDepthStencilStateCreateInfo_handle(VkPipelineDepthStencilStateCreateInfo * val)1456 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle(VkPipelineDepthStencilStateCreateInfo *val)
1457 {
1458 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1459
1460 do {
1461 switch ((int32_t)pnext->sType) {
1462 case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
1463 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle_self((VkPipelineDepthStencilStateCreateInfo *)pnext);
1464 break;
1465 default:
1466 /* ignore unknown/unsupported struct */
1467 break;
1468 }
1469 pnext = pnext->pNext;
1470 } while (pnext);
1471 }
1472
1473 /* struct VkPipelineColorBlendAttachmentState */
1474
1475 static inline void
vn_decode_VkPipelineColorBlendAttachmentState_temp(struct vn_cs_decoder * dec,VkPipelineColorBlendAttachmentState * val)1476 vn_decode_VkPipelineColorBlendAttachmentState_temp(struct vn_cs_decoder *dec, VkPipelineColorBlendAttachmentState *val)
1477 {
1478 vn_decode_VkBool32(dec, &val->blendEnable);
1479 vn_decode_VkBlendFactor(dec, &val->srcColorBlendFactor);
1480 vn_decode_VkBlendFactor(dec, &val->dstColorBlendFactor);
1481 vn_decode_VkBlendOp(dec, &val->colorBlendOp);
1482 vn_decode_VkBlendFactor(dec, &val->srcAlphaBlendFactor);
1483 vn_decode_VkBlendFactor(dec, &val->dstAlphaBlendFactor);
1484 vn_decode_VkBlendOp(dec, &val->alphaBlendOp);
1485 vn_decode_VkFlags(dec, &val->colorWriteMask);
1486 }
1487
1488 static inline void
vn_replace_VkPipelineColorBlendAttachmentState_handle(VkPipelineColorBlendAttachmentState * val)1489 vn_replace_VkPipelineColorBlendAttachmentState_handle(VkPipelineColorBlendAttachmentState *val)
1490 {
1491 /* skip val->blendEnable */
1492 /* skip val->srcColorBlendFactor */
1493 /* skip val->dstColorBlendFactor */
1494 /* skip val->colorBlendOp */
1495 /* skip val->srcAlphaBlendFactor */
1496 /* skip val->dstAlphaBlendFactor */
1497 /* skip val->alphaBlendOp */
1498 /* skip val->colorWriteMask */
1499 }
1500
1501 /* struct VkPipelineColorBlendStateCreateInfo chain */
1502
1503 static inline void *
vn_decode_VkPipelineColorBlendStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1504 vn_decode_VkPipelineColorBlendStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1505 {
1506 /* no known/supported struct */
1507 if (vn_decode_simple_pointer(dec))
1508 vn_cs_decoder_set_fatal(dec);
1509 return NULL;
1510 }
1511
1512 static inline void
vn_decode_VkPipelineColorBlendStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineColorBlendStateCreateInfo * val)1513 vn_decode_VkPipelineColorBlendStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateInfo *val)
1514 {
1515 /* skip val->{sType,pNext} */
1516 vn_decode_VkFlags(dec, &val->flags);
1517 vn_decode_VkBool32(dec, &val->logicOpEnable);
1518 vn_decode_VkLogicOp(dec, &val->logicOp);
1519 vn_decode_uint32_t(dec, &val->attachmentCount);
1520 if (vn_peek_array_size(dec)) {
1521 const uint32_t iter_count = vn_decode_array_size(dec, val->attachmentCount);
1522 val->pAttachments = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pAttachments) * iter_count);
1523 if (!val->pAttachments) return;
1524 for (uint32_t i = 0; i < iter_count; i++)
1525 vn_decode_VkPipelineColorBlendAttachmentState_temp(dec, &((VkPipelineColorBlendAttachmentState *)val->pAttachments)[i]);
1526 } else {
1527 vn_decode_array_size(dec, val->attachmentCount);
1528 val->pAttachments = NULL;
1529 }
1530 {
1531 const size_t array_size = vn_decode_array_size(dec, 4);
1532 vn_decode_float_array(dec, val->blendConstants, array_size);
1533 }
1534 }
1535
1536 static inline void
vn_decode_VkPipelineColorBlendStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineColorBlendStateCreateInfo * val)1537 vn_decode_VkPipelineColorBlendStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateInfo *val)
1538 {
1539 VkStructureType stype;
1540 vn_decode_VkStructureType(dec, &stype);
1541 if (stype != VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO)
1542 vn_cs_decoder_set_fatal(dec);
1543
1544 val->sType = stype;
1545 val->pNext = vn_decode_VkPipelineColorBlendStateCreateInfo_pnext_temp(dec);
1546 vn_decode_VkPipelineColorBlendStateCreateInfo_self_temp(dec, val);
1547 }
1548
1549 static inline void
vn_replace_VkPipelineColorBlendStateCreateInfo_handle_self(VkPipelineColorBlendStateCreateInfo * val)1550 vn_replace_VkPipelineColorBlendStateCreateInfo_handle_self(VkPipelineColorBlendStateCreateInfo *val)
1551 {
1552 /* skip val->sType */
1553 /* skip val->pNext */
1554 /* skip val->flags */
1555 /* skip val->logicOpEnable */
1556 /* skip val->logicOp */
1557 /* skip val->attachmentCount */
1558 if (val->pAttachments) {
1559 for (uint32_t i = 0; i < val->attachmentCount; i++)
1560 vn_replace_VkPipelineColorBlendAttachmentState_handle(&((VkPipelineColorBlendAttachmentState *)val->pAttachments)[i]);
1561 }
1562 /* skip val->blendConstants */
1563 }
1564
1565 static inline void
vn_replace_VkPipelineColorBlendStateCreateInfo_handle(VkPipelineColorBlendStateCreateInfo * val)1566 vn_replace_VkPipelineColorBlendStateCreateInfo_handle(VkPipelineColorBlendStateCreateInfo *val)
1567 {
1568 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1569
1570 do {
1571 switch ((int32_t)pnext->sType) {
1572 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
1573 vn_replace_VkPipelineColorBlendStateCreateInfo_handle_self((VkPipelineColorBlendStateCreateInfo *)pnext);
1574 break;
1575 default:
1576 /* ignore unknown/unsupported struct */
1577 break;
1578 }
1579 pnext = pnext->pNext;
1580 } while (pnext);
1581 }
1582
1583 /* struct VkPipelineDynamicStateCreateInfo chain */
1584
1585 static inline void *
vn_decode_VkPipelineDynamicStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1586 vn_decode_VkPipelineDynamicStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1587 {
1588 /* no known/supported struct */
1589 if (vn_decode_simple_pointer(dec))
1590 vn_cs_decoder_set_fatal(dec);
1591 return NULL;
1592 }
1593
1594 static inline void
vn_decode_VkPipelineDynamicStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineDynamicStateCreateInfo * val)1595 vn_decode_VkPipelineDynamicStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineDynamicStateCreateInfo *val)
1596 {
1597 /* skip val->{sType,pNext} */
1598 vn_decode_VkFlags(dec, &val->flags);
1599 vn_decode_uint32_t(dec, &val->dynamicStateCount);
1600 if (vn_peek_array_size(dec)) {
1601 const size_t array_size = vn_decode_array_size(dec, val->dynamicStateCount);
1602 val->pDynamicStates = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDynamicStates) * array_size);
1603 if (!val->pDynamicStates) return;
1604 vn_decode_VkDynamicState_array(dec, (VkDynamicState *)val->pDynamicStates, array_size);
1605 } else {
1606 vn_decode_array_size(dec, val->dynamicStateCount);
1607 val->pDynamicStates = NULL;
1608 }
1609 }
1610
1611 static inline void
vn_decode_VkPipelineDynamicStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineDynamicStateCreateInfo * val)1612 vn_decode_VkPipelineDynamicStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineDynamicStateCreateInfo *val)
1613 {
1614 VkStructureType stype;
1615 vn_decode_VkStructureType(dec, &stype);
1616 if (stype != VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO)
1617 vn_cs_decoder_set_fatal(dec);
1618
1619 val->sType = stype;
1620 val->pNext = vn_decode_VkPipelineDynamicStateCreateInfo_pnext_temp(dec);
1621 vn_decode_VkPipelineDynamicStateCreateInfo_self_temp(dec, val);
1622 }
1623
1624 static inline void
vn_replace_VkPipelineDynamicStateCreateInfo_handle_self(VkPipelineDynamicStateCreateInfo * val)1625 vn_replace_VkPipelineDynamicStateCreateInfo_handle_self(VkPipelineDynamicStateCreateInfo *val)
1626 {
1627 /* skip val->sType */
1628 /* skip val->pNext */
1629 /* skip val->flags */
1630 /* skip val->dynamicStateCount */
1631 /* skip val->pDynamicStates */
1632 }
1633
1634 static inline void
vn_replace_VkPipelineDynamicStateCreateInfo_handle(VkPipelineDynamicStateCreateInfo * val)1635 vn_replace_VkPipelineDynamicStateCreateInfo_handle(VkPipelineDynamicStateCreateInfo *val)
1636 {
1637 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1638
1639 do {
1640 switch ((int32_t)pnext->sType) {
1641 case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
1642 vn_replace_VkPipelineDynamicStateCreateInfo_handle_self((VkPipelineDynamicStateCreateInfo *)pnext);
1643 break;
1644 default:
1645 /* ignore unknown/unsupported struct */
1646 break;
1647 }
1648 pnext = pnext->pNext;
1649 } while (pnext);
1650 }
1651
1652 /* struct VkPipelineCreationFeedback */
1653
1654 static inline void
vn_decode_VkPipelineCreationFeedback_temp(struct vn_cs_decoder * dec,VkPipelineCreationFeedback * val)1655 vn_decode_VkPipelineCreationFeedback_temp(struct vn_cs_decoder *dec, VkPipelineCreationFeedback *val)
1656 {
1657 vn_decode_VkFlags(dec, &val->flags);
1658 vn_decode_uint64_t(dec, &val->duration);
1659 }
1660
1661 static inline void
vn_replace_VkPipelineCreationFeedback_handle(VkPipelineCreationFeedback * val)1662 vn_replace_VkPipelineCreationFeedback_handle(VkPipelineCreationFeedback *val)
1663 {
1664 /* skip val->flags */
1665 /* skip val->duration */
1666 }
1667
1668 /* struct VkPipelineCreationFeedbackCreateInfo chain */
1669
1670 static inline void *
vn_decode_VkPipelineCreationFeedbackCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1671 vn_decode_VkPipelineCreationFeedbackCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1672 {
1673 /* no known/supported struct */
1674 if (vn_decode_simple_pointer(dec))
1675 vn_cs_decoder_set_fatal(dec);
1676 return NULL;
1677 }
1678
1679 static inline void
vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineCreationFeedbackCreateInfo * val)1680 vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackCreateInfo *val)
1681 {
1682 /* skip val->{sType,pNext} */
1683 if (vn_decode_simple_pointer(dec)) {
1684 val->pPipelineCreationFeedback = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pPipelineCreationFeedback));
1685 if (!val->pPipelineCreationFeedback) return;
1686 vn_decode_VkPipelineCreationFeedback_temp(dec, val->pPipelineCreationFeedback);
1687 } else {
1688 val->pPipelineCreationFeedback = NULL;
1689 vn_cs_decoder_set_fatal(dec);
1690 }
1691 vn_decode_uint32_t(dec, &val->pipelineStageCreationFeedbackCount);
1692 if (vn_peek_array_size(dec)) {
1693 const uint32_t iter_count = vn_decode_array_size(dec, val->pipelineStageCreationFeedbackCount);
1694 val->pPipelineStageCreationFeedbacks = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pPipelineStageCreationFeedbacks) * iter_count);
1695 if (!val->pPipelineStageCreationFeedbacks) return;
1696 for (uint32_t i = 0; i < iter_count; i++)
1697 vn_decode_VkPipelineCreationFeedback_temp(dec, &val->pPipelineStageCreationFeedbacks[i]);
1698 } else {
1699 vn_decode_array_size(dec, val->pipelineStageCreationFeedbackCount);
1700 val->pPipelineStageCreationFeedbacks = NULL;
1701 }
1702 }
1703
1704 static inline void
vn_decode_VkPipelineCreationFeedbackCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineCreationFeedbackCreateInfo * val)1705 vn_decode_VkPipelineCreationFeedbackCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackCreateInfo *val)
1706 {
1707 VkStructureType stype;
1708 vn_decode_VkStructureType(dec, &stype);
1709 if (stype != VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO)
1710 vn_cs_decoder_set_fatal(dec);
1711
1712 val->sType = stype;
1713 val->pNext = vn_decode_VkPipelineCreationFeedbackCreateInfo_pnext_temp(dec);
1714 vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(dec, val);
1715 }
1716
1717 static inline void
vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self(VkPipelineCreationFeedbackCreateInfo * val)1718 vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self(VkPipelineCreationFeedbackCreateInfo *val)
1719 {
1720 /* skip val->sType */
1721 /* skip val->pNext */
1722 if (val->pPipelineCreationFeedback)
1723 vn_replace_VkPipelineCreationFeedback_handle(val->pPipelineCreationFeedback);
1724 /* skip val->pipelineStageCreationFeedbackCount */
1725 if (val->pPipelineStageCreationFeedbacks) {
1726 for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
1727 vn_replace_VkPipelineCreationFeedback_handle(&val->pPipelineStageCreationFeedbacks[i]);
1728 }
1729 }
1730
1731 static inline void
vn_replace_VkPipelineCreationFeedbackCreateInfo_handle(VkPipelineCreationFeedbackCreateInfo * val)1732 vn_replace_VkPipelineCreationFeedbackCreateInfo_handle(VkPipelineCreationFeedbackCreateInfo *val)
1733 {
1734 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1735
1736 do {
1737 switch ((int32_t)pnext->sType) {
1738 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
1739 vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self((VkPipelineCreationFeedbackCreateInfo *)pnext);
1740 break;
1741 default:
1742 /* ignore unknown/unsupported struct */
1743 break;
1744 }
1745 pnext = pnext->pNext;
1746 } while (pnext);
1747 }
1748
1749 /* struct VkPipelineRenderingCreateInfo chain */
1750
1751 static inline void *
vn_decode_VkPipelineRenderingCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1752 vn_decode_VkPipelineRenderingCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1753 {
1754 /* no known/supported struct */
1755 if (vn_decode_simple_pointer(dec))
1756 vn_cs_decoder_set_fatal(dec);
1757 return NULL;
1758 }
1759
1760 static inline void
vn_decode_VkPipelineRenderingCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineRenderingCreateInfo * val)1761 vn_decode_VkPipelineRenderingCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineRenderingCreateInfo *val)
1762 {
1763 /* skip val->{sType,pNext} */
1764 vn_decode_uint32_t(dec, &val->viewMask);
1765 vn_decode_uint32_t(dec, &val->colorAttachmentCount);
1766 if (vn_peek_array_size(dec)) {
1767 const size_t array_size = vn_decode_array_size(dec, val->colorAttachmentCount);
1768 val->pColorAttachmentFormats = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pColorAttachmentFormats) * array_size);
1769 if (!val->pColorAttachmentFormats) return;
1770 vn_decode_VkFormat_array(dec, (VkFormat *)val->pColorAttachmentFormats, array_size);
1771 } else {
1772 vn_decode_array_size_unchecked(dec);
1773 val->pColorAttachmentFormats = NULL;
1774 }
1775 vn_decode_VkFormat(dec, &val->depthAttachmentFormat);
1776 vn_decode_VkFormat(dec, &val->stencilAttachmentFormat);
1777 }
1778
1779 static inline void
vn_decode_VkPipelineRenderingCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineRenderingCreateInfo * val)1780 vn_decode_VkPipelineRenderingCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineRenderingCreateInfo *val)
1781 {
1782 VkStructureType stype;
1783 vn_decode_VkStructureType(dec, &stype);
1784 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO)
1785 vn_cs_decoder_set_fatal(dec);
1786
1787 val->sType = stype;
1788 val->pNext = vn_decode_VkPipelineRenderingCreateInfo_pnext_temp(dec);
1789 vn_decode_VkPipelineRenderingCreateInfo_self_temp(dec, val);
1790 }
1791
1792 static inline void
vn_replace_VkPipelineRenderingCreateInfo_handle_self(VkPipelineRenderingCreateInfo * val)1793 vn_replace_VkPipelineRenderingCreateInfo_handle_self(VkPipelineRenderingCreateInfo *val)
1794 {
1795 /* skip val->sType */
1796 /* skip val->pNext */
1797 /* skip val->viewMask */
1798 /* skip val->colorAttachmentCount */
1799 /* skip val->pColorAttachmentFormats */
1800 /* skip val->depthAttachmentFormat */
1801 /* skip val->stencilAttachmentFormat */
1802 }
1803
1804 static inline void
vn_replace_VkPipelineRenderingCreateInfo_handle(VkPipelineRenderingCreateInfo * val)1805 vn_replace_VkPipelineRenderingCreateInfo_handle(VkPipelineRenderingCreateInfo *val)
1806 {
1807 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1808
1809 do {
1810 switch ((int32_t)pnext->sType) {
1811 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
1812 vn_replace_VkPipelineRenderingCreateInfo_handle_self((VkPipelineRenderingCreateInfo *)pnext);
1813 break;
1814 default:
1815 /* ignore unknown/unsupported struct */
1816 break;
1817 }
1818 pnext = pnext->pNext;
1819 } while (pnext);
1820 }
1821
1822 /* struct VkGraphicsPipelineCreateInfo chain */
1823
1824 static inline void *
vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1825 vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1826 {
1827 VkBaseOutStructure *pnext;
1828 VkStructureType stype;
1829
1830 if (!vn_decode_simple_pointer(dec))
1831 return NULL;
1832
1833 vn_decode_VkStructureType(dec, &stype);
1834 switch ((int32_t)stype) {
1835 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
1836 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineCreationFeedbackCreateInfo));
1837 if (pnext) {
1838 pnext->sType = stype;
1839 pnext->pNext = vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(dec);
1840 vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(dec, (VkPipelineCreationFeedbackCreateInfo *)pnext);
1841 }
1842 break;
1843 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
1844 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRenderingCreateInfo));
1845 if (pnext) {
1846 pnext->sType = stype;
1847 pnext->pNext = vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(dec);
1848 vn_decode_VkPipelineRenderingCreateInfo_self_temp(dec, (VkPipelineRenderingCreateInfo *)pnext);
1849 }
1850 break;
1851 default:
1852 /* unexpected struct */
1853 pnext = NULL;
1854 vn_cs_decoder_set_fatal(dec);
1855 break;
1856 }
1857
1858 return pnext;
1859 }
1860
1861 static inline void
vn_decode_VkGraphicsPipelineCreateInfo_self_temp(struct vn_cs_decoder * dec,VkGraphicsPipelineCreateInfo * val)1862 vn_decode_VkGraphicsPipelineCreateInfo_self_temp(struct vn_cs_decoder *dec, VkGraphicsPipelineCreateInfo *val)
1863 {
1864 /* skip val->{sType,pNext} */
1865 vn_decode_VkFlags(dec, &val->flags);
1866 vn_decode_uint32_t(dec, &val->stageCount);
1867 if (vn_peek_array_size(dec)) {
1868 const uint32_t iter_count = vn_decode_array_size(dec, val->stageCount);
1869 val->pStages = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pStages) * iter_count);
1870 if (!val->pStages) return;
1871 for (uint32_t i = 0; i < iter_count; i++)
1872 vn_decode_VkPipelineShaderStageCreateInfo_temp(dec, &((VkPipelineShaderStageCreateInfo *)val->pStages)[i]);
1873 } else {
1874 vn_decode_array_size_unchecked(dec);
1875 val->pStages = NULL;
1876 }
1877 if (vn_decode_simple_pointer(dec)) {
1878 val->pVertexInputState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pVertexInputState));
1879 if (!val->pVertexInputState) return;
1880 vn_decode_VkPipelineVertexInputStateCreateInfo_temp(dec, (VkPipelineVertexInputStateCreateInfo *)val->pVertexInputState);
1881 } else {
1882 val->pVertexInputState = NULL;
1883 }
1884 if (vn_decode_simple_pointer(dec)) {
1885 val->pInputAssemblyState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pInputAssemblyState));
1886 if (!val->pInputAssemblyState) return;
1887 vn_decode_VkPipelineInputAssemblyStateCreateInfo_temp(dec, (VkPipelineInputAssemblyStateCreateInfo *)val->pInputAssemblyState);
1888 } else {
1889 val->pInputAssemblyState = NULL;
1890 }
1891 if (vn_decode_simple_pointer(dec)) {
1892 val->pTessellationState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pTessellationState));
1893 if (!val->pTessellationState) return;
1894 vn_decode_VkPipelineTessellationStateCreateInfo_temp(dec, (VkPipelineTessellationStateCreateInfo *)val->pTessellationState);
1895 } else {
1896 val->pTessellationState = NULL;
1897 }
1898 if (vn_decode_simple_pointer(dec)) {
1899 val->pViewportState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pViewportState));
1900 if (!val->pViewportState) return;
1901 vn_decode_VkPipelineViewportStateCreateInfo_temp(dec, (VkPipelineViewportStateCreateInfo *)val->pViewportState);
1902 } else {
1903 val->pViewportState = NULL;
1904 }
1905 if (vn_decode_simple_pointer(dec)) {
1906 val->pRasterizationState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRasterizationState));
1907 if (!val->pRasterizationState) return;
1908 vn_decode_VkPipelineRasterizationStateCreateInfo_temp(dec, (VkPipelineRasterizationStateCreateInfo *)val->pRasterizationState);
1909 } else {
1910 val->pRasterizationState = NULL;
1911 }
1912 if (vn_decode_simple_pointer(dec)) {
1913 val->pMultisampleState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pMultisampleState));
1914 if (!val->pMultisampleState) return;
1915 vn_decode_VkPipelineMultisampleStateCreateInfo_temp(dec, (VkPipelineMultisampleStateCreateInfo *)val->pMultisampleState);
1916 } else {
1917 val->pMultisampleState = NULL;
1918 }
1919 if (vn_decode_simple_pointer(dec)) {
1920 val->pDepthStencilState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDepthStencilState));
1921 if (!val->pDepthStencilState) return;
1922 vn_decode_VkPipelineDepthStencilStateCreateInfo_temp(dec, (VkPipelineDepthStencilStateCreateInfo *)val->pDepthStencilState);
1923 } else {
1924 val->pDepthStencilState = NULL;
1925 }
1926 if (vn_decode_simple_pointer(dec)) {
1927 val->pColorBlendState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pColorBlendState));
1928 if (!val->pColorBlendState) return;
1929 vn_decode_VkPipelineColorBlendStateCreateInfo_temp(dec, (VkPipelineColorBlendStateCreateInfo *)val->pColorBlendState);
1930 } else {
1931 val->pColorBlendState = NULL;
1932 }
1933 if (vn_decode_simple_pointer(dec)) {
1934 val->pDynamicState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDynamicState));
1935 if (!val->pDynamicState) return;
1936 vn_decode_VkPipelineDynamicStateCreateInfo_temp(dec, (VkPipelineDynamicStateCreateInfo *)val->pDynamicState);
1937 } else {
1938 val->pDynamicState = NULL;
1939 }
1940 vn_decode_VkPipelineLayout_lookup(dec, &val->layout);
1941 vn_decode_VkRenderPass_lookup(dec, &val->renderPass);
1942 vn_decode_uint32_t(dec, &val->subpass);
1943 vn_decode_VkPipeline_lookup(dec, &val->basePipelineHandle);
1944 vn_decode_int32_t(dec, &val->basePipelineIndex);
1945 }
1946
1947 static inline void
vn_decode_VkGraphicsPipelineCreateInfo_temp(struct vn_cs_decoder * dec,VkGraphicsPipelineCreateInfo * val)1948 vn_decode_VkGraphicsPipelineCreateInfo_temp(struct vn_cs_decoder *dec, VkGraphicsPipelineCreateInfo *val)
1949 {
1950 VkStructureType stype;
1951 vn_decode_VkStructureType(dec, &stype);
1952 if (stype != VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
1953 vn_cs_decoder_set_fatal(dec);
1954
1955 val->sType = stype;
1956 val->pNext = vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(dec);
1957 vn_decode_VkGraphicsPipelineCreateInfo_self_temp(dec, val);
1958 }
1959
1960 static inline void
vn_replace_VkGraphicsPipelineCreateInfo_handle_self(VkGraphicsPipelineCreateInfo * val)1961 vn_replace_VkGraphicsPipelineCreateInfo_handle_self(VkGraphicsPipelineCreateInfo *val)
1962 {
1963 /* skip val->sType */
1964 /* skip val->pNext */
1965 /* skip val->flags */
1966 /* skip val->stageCount */
1967 if (val->pStages) {
1968 for (uint32_t i = 0; i < val->stageCount; i++)
1969 vn_replace_VkPipelineShaderStageCreateInfo_handle(&((VkPipelineShaderStageCreateInfo *)val->pStages)[i]);
1970 }
1971 if (val->pVertexInputState)
1972 vn_replace_VkPipelineVertexInputStateCreateInfo_handle((VkPipelineVertexInputStateCreateInfo *)val->pVertexInputState);
1973 if (val->pInputAssemblyState)
1974 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle((VkPipelineInputAssemblyStateCreateInfo *)val->pInputAssemblyState);
1975 if (val->pTessellationState)
1976 vn_replace_VkPipelineTessellationStateCreateInfo_handle((VkPipelineTessellationStateCreateInfo *)val->pTessellationState);
1977 if (val->pViewportState)
1978 vn_replace_VkPipelineViewportStateCreateInfo_handle((VkPipelineViewportStateCreateInfo *)val->pViewportState);
1979 if (val->pRasterizationState)
1980 vn_replace_VkPipelineRasterizationStateCreateInfo_handle((VkPipelineRasterizationStateCreateInfo *)val->pRasterizationState);
1981 if (val->pMultisampleState)
1982 vn_replace_VkPipelineMultisampleStateCreateInfo_handle((VkPipelineMultisampleStateCreateInfo *)val->pMultisampleState);
1983 if (val->pDepthStencilState)
1984 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle((VkPipelineDepthStencilStateCreateInfo *)val->pDepthStencilState);
1985 if (val->pColorBlendState)
1986 vn_replace_VkPipelineColorBlendStateCreateInfo_handle((VkPipelineColorBlendStateCreateInfo *)val->pColorBlendState);
1987 if (val->pDynamicState)
1988 vn_replace_VkPipelineDynamicStateCreateInfo_handle((VkPipelineDynamicStateCreateInfo *)val->pDynamicState);
1989 vn_replace_VkPipelineLayout_handle(&val->layout);
1990 vn_replace_VkRenderPass_handle(&val->renderPass);
1991 /* skip val->subpass */
1992 vn_replace_VkPipeline_handle(&val->basePipelineHandle);
1993 /* skip val->basePipelineIndex */
1994 }
1995
1996 static inline void
vn_replace_VkGraphicsPipelineCreateInfo_handle(VkGraphicsPipelineCreateInfo * val)1997 vn_replace_VkGraphicsPipelineCreateInfo_handle(VkGraphicsPipelineCreateInfo *val)
1998 {
1999 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2000
2001 do {
2002 switch ((int32_t)pnext->sType) {
2003 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
2004 vn_replace_VkGraphicsPipelineCreateInfo_handle_self((VkGraphicsPipelineCreateInfo *)pnext);
2005 break;
2006 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
2007 vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self((VkPipelineCreationFeedbackCreateInfo *)pnext);
2008 break;
2009 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
2010 vn_replace_VkPipelineRenderingCreateInfo_handle_self((VkPipelineRenderingCreateInfo *)pnext);
2011 break;
2012 default:
2013 /* ignore unknown/unsupported struct */
2014 break;
2015 }
2016 pnext = pnext->pNext;
2017 } while (pnext);
2018 }
2019
2020 /* struct VkComputePipelineCreateInfo chain */
2021
2022 static inline void *
vn_decode_VkComputePipelineCreateInfo_pnext_temp(struct vn_cs_decoder * dec)2023 vn_decode_VkComputePipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
2024 {
2025 VkBaseOutStructure *pnext;
2026 VkStructureType stype;
2027
2028 if (!vn_decode_simple_pointer(dec))
2029 return NULL;
2030
2031 vn_decode_VkStructureType(dec, &stype);
2032 switch ((int32_t)stype) {
2033 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
2034 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineCreationFeedbackCreateInfo));
2035 if (pnext) {
2036 pnext->sType = stype;
2037 pnext->pNext = vn_decode_VkComputePipelineCreateInfo_pnext_temp(dec);
2038 vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(dec, (VkPipelineCreationFeedbackCreateInfo *)pnext);
2039 }
2040 break;
2041 default:
2042 /* unexpected struct */
2043 pnext = NULL;
2044 vn_cs_decoder_set_fatal(dec);
2045 break;
2046 }
2047
2048 return pnext;
2049 }
2050
2051 static inline void
vn_decode_VkComputePipelineCreateInfo_self_temp(struct vn_cs_decoder * dec,VkComputePipelineCreateInfo * val)2052 vn_decode_VkComputePipelineCreateInfo_self_temp(struct vn_cs_decoder *dec, VkComputePipelineCreateInfo *val)
2053 {
2054 /* skip val->{sType,pNext} */
2055 vn_decode_VkFlags(dec, &val->flags);
2056 vn_decode_VkPipelineShaderStageCreateInfo_temp(dec, &val->stage);
2057 vn_decode_VkPipelineLayout_lookup(dec, &val->layout);
2058 vn_decode_VkPipeline_lookup(dec, &val->basePipelineHandle);
2059 vn_decode_int32_t(dec, &val->basePipelineIndex);
2060 }
2061
2062 static inline void
vn_decode_VkComputePipelineCreateInfo_temp(struct vn_cs_decoder * dec,VkComputePipelineCreateInfo * val)2063 vn_decode_VkComputePipelineCreateInfo_temp(struct vn_cs_decoder *dec, VkComputePipelineCreateInfo *val)
2064 {
2065 VkStructureType stype;
2066 vn_decode_VkStructureType(dec, &stype);
2067 if (stype != VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO)
2068 vn_cs_decoder_set_fatal(dec);
2069
2070 val->sType = stype;
2071 val->pNext = vn_decode_VkComputePipelineCreateInfo_pnext_temp(dec);
2072 vn_decode_VkComputePipelineCreateInfo_self_temp(dec, val);
2073 }
2074
2075 static inline void
vn_replace_VkComputePipelineCreateInfo_handle_self(VkComputePipelineCreateInfo * val)2076 vn_replace_VkComputePipelineCreateInfo_handle_self(VkComputePipelineCreateInfo *val)
2077 {
2078 /* skip val->sType */
2079 /* skip val->pNext */
2080 /* skip val->flags */
2081 vn_replace_VkPipelineShaderStageCreateInfo_handle(&val->stage);
2082 vn_replace_VkPipelineLayout_handle(&val->layout);
2083 vn_replace_VkPipeline_handle(&val->basePipelineHandle);
2084 /* skip val->basePipelineIndex */
2085 }
2086
2087 static inline void
vn_replace_VkComputePipelineCreateInfo_handle(VkComputePipelineCreateInfo * val)2088 vn_replace_VkComputePipelineCreateInfo_handle(VkComputePipelineCreateInfo *val)
2089 {
2090 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
2091
2092 do {
2093 switch ((int32_t)pnext->sType) {
2094 case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
2095 vn_replace_VkComputePipelineCreateInfo_handle_self((VkComputePipelineCreateInfo *)pnext);
2096 break;
2097 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
2098 vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self((VkPipelineCreationFeedbackCreateInfo *)pnext);
2099 break;
2100 default:
2101 /* ignore unknown/unsupported struct */
2102 break;
2103 }
2104 pnext = pnext->pNext;
2105 } while (pnext);
2106 }
2107
vn_decode_vkCreateGraphicsPipelines_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCreateGraphicsPipelines * args)2108 static inline void vn_decode_vkCreateGraphicsPipelines_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreateGraphicsPipelines *args)
2109 {
2110 vn_decode_VkDevice_lookup(dec, &args->device);
2111 vn_decode_VkPipelineCache_lookup(dec, &args->pipelineCache);
2112 vn_decode_uint32_t(dec, &args->createInfoCount);
2113 if (vn_peek_array_size(dec)) {
2114 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
2115 args->pCreateInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfos) * iter_count);
2116 if (!args->pCreateInfos) return;
2117 for (uint32_t i = 0; i < iter_count; i++)
2118 vn_decode_VkGraphicsPipelineCreateInfo_temp(dec, &((VkGraphicsPipelineCreateInfo *)args->pCreateInfos)[i]);
2119 } else {
2120 vn_decode_array_size(dec, args->createInfoCount);
2121 args->pCreateInfos = NULL;
2122 }
2123 if (vn_decode_simple_pointer(dec)) {
2124 vn_cs_decoder_set_fatal(dec);
2125 } else {
2126 args->pAllocator = NULL;
2127 }
2128 if (vn_peek_array_size(dec)) {
2129 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
2130 args->pPipelines = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPipelines) * iter_count);
2131 if (!args->pPipelines) return;
2132 for (uint32_t i = 0; i < iter_count; i++)
2133 vn_decode_VkPipeline(dec, &args->pPipelines[i]);
2134 } else {
2135 vn_decode_array_size(dec, args->createInfoCount);
2136 args->pPipelines = NULL;
2137 }
2138 }
2139
vn_replace_vkCreateGraphicsPipelines_args_handle(struct vn_command_vkCreateGraphicsPipelines * args)2140 static inline void vn_replace_vkCreateGraphicsPipelines_args_handle(struct vn_command_vkCreateGraphicsPipelines *args)
2141 {
2142 vn_replace_VkDevice_handle(&args->device);
2143 vn_replace_VkPipelineCache_handle(&args->pipelineCache);
2144 /* skip args->createInfoCount */
2145 if (args->pCreateInfos) {
2146 for (uint32_t i = 0; i < args->createInfoCount; i++)
2147 vn_replace_VkGraphicsPipelineCreateInfo_handle(&((VkGraphicsPipelineCreateInfo *)args->pCreateInfos)[i]);
2148 }
2149 /* skip args->pAllocator */
2150 /* skip args->pPipelines */
2151 }
2152
vn_encode_vkCreateGraphicsPipelines_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCreateGraphicsPipelines * args)2153 static inline void vn_encode_vkCreateGraphicsPipelines_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreateGraphicsPipelines *args)
2154 {
2155 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT});
2156
2157 vn_encode_VkResult(enc, &args->ret);
2158 /* skip args->device */
2159 /* skip args->pipelineCache */
2160 /* skip args->createInfoCount */
2161 /* skip args->pCreateInfos */
2162 /* skip args->pAllocator */
2163 if (args->pPipelines) {
2164 vn_encode_array_size(enc, args->createInfoCount);
2165 for (uint32_t i = 0; i < args->createInfoCount; i++)
2166 vn_encode_VkPipeline(enc, &args->pPipelines[i]);
2167 } else {
2168 vn_encode_array_size(enc, 0);
2169 }
2170 }
2171
vn_decode_vkCreateComputePipelines_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCreateComputePipelines * args)2172 static inline void vn_decode_vkCreateComputePipelines_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreateComputePipelines *args)
2173 {
2174 vn_decode_VkDevice_lookup(dec, &args->device);
2175 vn_decode_VkPipelineCache_lookup(dec, &args->pipelineCache);
2176 vn_decode_uint32_t(dec, &args->createInfoCount);
2177 if (vn_peek_array_size(dec)) {
2178 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
2179 args->pCreateInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfos) * iter_count);
2180 if (!args->pCreateInfos) return;
2181 for (uint32_t i = 0; i < iter_count; i++)
2182 vn_decode_VkComputePipelineCreateInfo_temp(dec, &((VkComputePipelineCreateInfo *)args->pCreateInfos)[i]);
2183 } else {
2184 vn_decode_array_size(dec, args->createInfoCount);
2185 args->pCreateInfos = NULL;
2186 }
2187 if (vn_decode_simple_pointer(dec)) {
2188 vn_cs_decoder_set_fatal(dec);
2189 } else {
2190 args->pAllocator = NULL;
2191 }
2192 if (vn_peek_array_size(dec)) {
2193 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
2194 args->pPipelines = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPipelines) * iter_count);
2195 if (!args->pPipelines) return;
2196 for (uint32_t i = 0; i < iter_count; i++)
2197 vn_decode_VkPipeline(dec, &args->pPipelines[i]);
2198 } else {
2199 vn_decode_array_size(dec, args->createInfoCount);
2200 args->pPipelines = NULL;
2201 }
2202 }
2203
vn_replace_vkCreateComputePipelines_args_handle(struct vn_command_vkCreateComputePipelines * args)2204 static inline void vn_replace_vkCreateComputePipelines_args_handle(struct vn_command_vkCreateComputePipelines *args)
2205 {
2206 vn_replace_VkDevice_handle(&args->device);
2207 vn_replace_VkPipelineCache_handle(&args->pipelineCache);
2208 /* skip args->createInfoCount */
2209 if (args->pCreateInfos) {
2210 for (uint32_t i = 0; i < args->createInfoCount; i++)
2211 vn_replace_VkComputePipelineCreateInfo_handle(&((VkComputePipelineCreateInfo *)args->pCreateInfos)[i]);
2212 }
2213 /* skip args->pAllocator */
2214 /* skip args->pPipelines */
2215 }
2216
vn_encode_vkCreateComputePipelines_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCreateComputePipelines * args)2217 static inline void vn_encode_vkCreateComputePipelines_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreateComputePipelines *args)
2218 {
2219 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreateComputePipelines_EXT});
2220
2221 vn_encode_VkResult(enc, &args->ret);
2222 /* skip args->device */
2223 /* skip args->pipelineCache */
2224 /* skip args->createInfoCount */
2225 /* skip args->pCreateInfos */
2226 /* skip args->pAllocator */
2227 if (args->pPipelines) {
2228 vn_encode_array_size(enc, args->createInfoCount);
2229 for (uint32_t i = 0; i < args->createInfoCount; i++)
2230 vn_encode_VkPipeline(enc, &args->pPipelines[i]);
2231 } else {
2232 vn_encode_array_size(enc, 0);
2233 }
2234 }
2235
vn_decode_vkDestroyPipeline_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkDestroyPipeline * args)2236 static inline void vn_decode_vkDestroyPipeline_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkDestroyPipeline *args)
2237 {
2238 vn_decode_VkDevice_lookup(dec, &args->device);
2239 vn_decode_VkPipeline_lookup(dec, &args->pipeline);
2240 if (vn_decode_simple_pointer(dec)) {
2241 vn_cs_decoder_set_fatal(dec);
2242 } else {
2243 args->pAllocator = NULL;
2244 }
2245 }
2246
vn_replace_vkDestroyPipeline_args_handle(struct vn_command_vkDestroyPipeline * args)2247 static inline void vn_replace_vkDestroyPipeline_args_handle(struct vn_command_vkDestroyPipeline *args)
2248 {
2249 vn_replace_VkDevice_handle(&args->device);
2250 vn_replace_VkPipeline_handle(&args->pipeline);
2251 /* skip args->pAllocator */
2252 }
2253
vn_encode_vkDestroyPipeline_reply(struct vn_cs_encoder * enc,const struct vn_command_vkDestroyPipeline * args)2254 static inline void vn_encode_vkDestroyPipeline_reply(struct vn_cs_encoder *enc, const struct vn_command_vkDestroyPipeline *args)
2255 {
2256 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkDestroyPipeline_EXT});
2257
2258 /* skip args->device */
2259 /* skip args->pipeline */
2260 /* skip args->pAllocator */
2261 }
2262
vn_dispatch_vkCreateGraphicsPipelines(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)2263 static inline void vn_dispatch_vkCreateGraphicsPipelines(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
2264 {
2265 struct vn_command_vkCreateGraphicsPipelines args;
2266
2267 if (!ctx->dispatch_vkCreateGraphicsPipelines) {
2268 vn_cs_decoder_set_fatal(ctx->decoder);
2269 return;
2270 }
2271
2272 vn_decode_vkCreateGraphicsPipelines_args_temp(ctx->decoder, &args);
2273 if (!args.device) {
2274 vn_cs_decoder_set_fatal(ctx->decoder);
2275 return;
2276 }
2277
2278 if (!vn_cs_decoder_get_fatal(ctx->decoder))
2279 ctx->dispatch_vkCreateGraphicsPipelines(ctx, &args);
2280
2281 #ifdef DEBUG
2282 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
2283 vn_dispatch_debug_log(ctx, "vkCreateGraphicsPipelines returned %d", args.ret);
2284 #endif
2285
2286 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
2287 vn_encode_vkCreateGraphicsPipelines_reply(ctx->encoder, &args);
2288
2289 vn_cs_decoder_reset_temp_pool(ctx->decoder);
2290 }
2291
vn_dispatch_vkCreateComputePipelines(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)2292 static inline void vn_dispatch_vkCreateComputePipelines(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
2293 {
2294 struct vn_command_vkCreateComputePipelines args;
2295
2296 if (!ctx->dispatch_vkCreateComputePipelines) {
2297 vn_cs_decoder_set_fatal(ctx->decoder);
2298 return;
2299 }
2300
2301 vn_decode_vkCreateComputePipelines_args_temp(ctx->decoder, &args);
2302 if (!args.device) {
2303 vn_cs_decoder_set_fatal(ctx->decoder);
2304 return;
2305 }
2306
2307 if (!vn_cs_decoder_get_fatal(ctx->decoder))
2308 ctx->dispatch_vkCreateComputePipelines(ctx, &args);
2309
2310 #ifdef DEBUG
2311 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
2312 vn_dispatch_debug_log(ctx, "vkCreateComputePipelines returned %d", args.ret);
2313 #endif
2314
2315 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
2316 vn_encode_vkCreateComputePipelines_reply(ctx->encoder, &args);
2317
2318 vn_cs_decoder_reset_temp_pool(ctx->decoder);
2319 }
2320
vn_dispatch_vkDestroyPipeline(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)2321 static inline void vn_dispatch_vkDestroyPipeline(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
2322 {
2323 struct vn_command_vkDestroyPipeline args;
2324
2325 if (!ctx->dispatch_vkDestroyPipeline) {
2326 vn_cs_decoder_set_fatal(ctx->decoder);
2327 return;
2328 }
2329
2330 vn_decode_vkDestroyPipeline_args_temp(ctx->decoder, &args);
2331 if (!args.device) {
2332 vn_cs_decoder_set_fatal(ctx->decoder);
2333 return;
2334 }
2335
2336 if (!vn_cs_decoder_get_fatal(ctx->decoder))
2337 ctx->dispatch_vkDestroyPipeline(ctx, &args);
2338
2339
2340 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
2341 vn_encode_vkDestroyPipeline_reply(ctx->encoder, &args);
2342
2343 vn_cs_decoder_reset_temp_pool(ctx->decoder);
2344 }
2345
2346 #pragma GCC diagnostic pop
2347
2348 #endif /* VN_PROTOCOL_RENDERER_PIPELINE_H */
2349