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 VkPipelineShaderStageCreateInfo chain */
76
77 static inline void *
vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(struct vn_cs_decoder * dec)78 vn_decode_VkPipelineShaderStageCreateInfo_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_VkPipelineShaderStageCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineShaderStageCreateInfo * val)87 vn_decode_VkPipelineShaderStageCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateInfo *val)
88 {
89 /* skip val->{sType,pNext} */
90 vn_decode_VkFlags(dec, &val->flags);
91 vn_decode_VkShaderStageFlagBits(dec, &val->stage);
92 vn_decode_VkShaderModule_lookup(dec, &val->module);
93 if (vn_peek_array_size(dec)) {
94 const size_t string_size = vn_decode_array_size_unchecked(dec);
95 val->pName = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pName) * string_size);
96 if (!val->pName) return;
97 vn_decode_char_array(dec, (char *)val->pName, string_size);
98 } else {
99 vn_decode_array_size_unchecked(dec);
100 val->pName = NULL;
101 }
102 if (vn_decode_simple_pointer(dec)) {
103 val->pSpecializationInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pSpecializationInfo));
104 if (!val->pSpecializationInfo) return;
105 vn_decode_VkSpecializationInfo_temp(dec, (VkSpecializationInfo *)val->pSpecializationInfo);
106 } else {
107 val->pSpecializationInfo = NULL;
108 }
109 }
110
111 static inline void
vn_decode_VkPipelineShaderStageCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineShaderStageCreateInfo * val)112 vn_decode_VkPipelineShaderStageCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateInfo *val)
113 {
114 VkStructureType stype;
115 vn_decode_VkStructureType(dec, &stype);
116 if (stype != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
117 vn_cs_decoder_set_fatal(dec);
118
119 val->sType = stype;
120 val->pNext = vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(dec);
121 vn_decode_VkPipelineShaderStageCreateInfo_self_temp(dec, val);
122 }
123
124 static inline void
vn_replace_VkPipelineShaderStageCreateInfo_handle_self(VkPipelineShaderStageCreateInfo * val)125 vn_replace_VkPipelineShaderStageCreateInfo_handle_self(VkPipelineShaderStageCreateInfo *val)
126 {
127 /* skip val->sType */
128 /* skip val->pNext */
129 /* skip val->flags */
130 /* skip val->stage */
131 vn_replace_VkShaderModule_handle(&val->module);
132 /* skip val->pName */
133 if (val->pSpecializationInfo)
134 vn_replace_VkSpecializationInfo_handle((VkSpecializationInfo *)val->pSpecializationInfo);
135 }
136
137 static inline void
vn_replace_VkPipelineShaderStageCreateInfo_handle(VkPipelineShaderStageCreateInfo * val)138 vn_replace_VkPipelineShaderStageCreateInfo_handle(VkPipelineShaderStageCreateInfo *val)
139 {
140 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
141
142 do {
143 switch ((int32_t)pnext->sType) {
144 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
145 vn_replace_VkPipelineShaderStageCreateInfo_handle_self((VkPipelineShaderStageCreateInfo *)pnext);
146 break;
147 default:
148 /* ignore unknown/unsupported struct */
149 break;
150 }
151 pnext = pnext->pNext;
152 } while (pnext);
153 }
154
155 /* struct VkVertexInputBindingDescription */
156
157 static inline void
vn_decode_VkVertexInputBindingDescription_temp(struct vn_cs_decoder * dec,VkVertexInputBindingDescription * val)158 vn_decode_VkVertexInputBindingDescription_temp(struct vn_cs_decoder *dec, VkVertexInputBindingDescription *val)
159 {
160 vn_decode_uint32_t(dec, &val->binding);
161 vn_decode_uint32_t(dec, &val->stride);
162 vn_decode_VkVertexInputRate(dec, &val->inputRate);
163 }
164
165 static inline void
vn_replace_VkVertexInputBindingDescription_handle(VkVertexInputBindingDescription * val)166 vn_replace_VkVertexInputBindingDescription_handle(VkVertexInputBindingDescription *val)
167 {
168 /* skip val->binding */
169 /* skip val->stride */
170 /* skip val->inputRate */
171 }
172
173 /* struct VkVertexInputAttributeDescription */
174
175 static inline void
vn_decode_VkVertexInputAttributeDescription_temp(struct vn_cs_decoder * dec,VkVertexInputAttributeDescription * val)176 vn_decode_VkVertexInputAttributeDescription_temp(struct vn_cs_decoder *dec, VkVertexInputAttributeDescription *val)
177 {
178 vn_decode_uint32_t(dec, &val->location);
179 vn_decode_uint32_t(dec, &val->binding);
180 vn_decode_VkFormat(dec, &val->format);
181 vn_decode_uint32_t(dec, &val->offset);
182 }
183
184 static inline void
vn_replace_VkVertexInputAttributeDescription_handle(VkVertexInputAttributeDescription * val)185 vn_replace_VkVertexInputAttributeDescription_handle(VkVertexInputAttributeDescription *val)
186 {
187 /* skip val->location */
188 /* skip val->binding */
189 /* skip val->format */
190 /* skip val->offset */
191 }
192
193 /* struct VkPipelineVertexInputStateCreateInfo chain */
194
195 static inline void *
vn_decode_VkPipelineVertexInputStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)196 vn_decode_VkPipelineVertexInputStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
197 {
198 /* no known/supported struct */
199 if (vn_decode_simple_pointer(dec))
200 vn_cs_decoder_set_fatal(dec);
201 return NULL;
202 }
203
204 static inline void
vn_decode_VkPipelineVertexInputStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineVertexInputStateCreateInfo * val)205 vn_decode_VkPipelineVertexInputStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineVertexInputStateCreateInfo *val)
206 {
207 /* skip val->{sType,pNext} */
208 vn_decode_VkFlags(dec, &val->flags);
209 vn_decode_uint32_t(dec, &val->vertexBindingDescriptionCount);
210 if (vn_peek_array_size(dec)) {
211 const uint32_t iter_count = vn_decode_array_size(dec, val->vertexBindingDescriptionCount);
212 val->pVertexBindingDescriptions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pVertexBindingDescriptions) * iter_count);
213 if (!val->pVertexBindingDescriptions) return;
214 for (uint32_t i = 0; i < iter_count; i++)
215 vn_decode_VkVertexInputBindingDescription_temp(dec, &((VkVertexInputBindingDescription *)val->pVertexBindingDescriptions)[i]);
216 } else {
217 vn_decode_array_size(dec, val->vertexBindingDescriptionCount);
218 val->pVertexBindingDescriptions = NULL;
219 }
220 vn_decode_uint32_t(dec, &val->vertexAttributeDescriptionCount);
221 if (vn_peek_array_size(dec)) {
222 const uint32_t iter_count = vn_decode_array_size(dec, val->vertexAttributeDescriptionCount);
223 val->pVertexAttributeDescriptions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pVertexAttributeDescriptions) * iter_count);
224 if (!val->pVertexAttributeDescriptions) return;
225 for (uint32_t i = 0; i < iter_count; i++)
226 vn_decode_VkVertexInputAttributeDescription_temp(dec, &((VkVertexInputAttributeDescription *)val->pVertexAttributeDescriptions)[i]);
227 } else {
228 vn_decode_array_size(dec, val->vertexAttributeDescriptionCount);
229 val->pVertexAttributeDescriptions = NULL;
230 }
231 }
232
233 static inline void
vn_decode_VkPipelineVertexInputStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineVertexInputStateCreateInfo * val)234 vn_decode_VkPipelineVertexInputStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineVertexInputStateCreateInfo *val)
235 {
236 VkStructureType stype;
237 vn_decode_VkStructureType(dec, &stype);
238 if (stype != VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO)
239 vn_cs_decoder_set_fatal(dec);
240
241 val->sType = stype;
242 val->pNext = vn_decode_VkPipelineVertexInputStateCreateInfo_pnext_temp(dec);
243 vn_decode_VkPipelineVertexInputStateCreateInfo_self_temp(dec, val);
244 }
245
246 static inline void
vn_replace_VkPipelineVertexInputStateCreateInfo_handle_self(VkPipelineVertexInputStateCreateInfo * val)247 vn_replace_VkPipelineVertexInputStateCreateInfo_handle_self(VkPipelineVertexInputStateCreateInfo *val)
248 {
249 /* skip val->sType */
250 /* skip val->pNext */
251 /* skip val->flags */
252 /* skip val->vertexBindingDescriptionCount */
253 if (val->pVertexBindingDescriptions) {
254 for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
255 vn_replace_VkVertexInputBindingDescription_handle(&((VkVertexInputBindingDescription *)val->pVertexBindingDescriptions)[i]);
256 }
257 /* skip val->vertexAttributeDescriptionCount */
258 if (val->pVertexAttributeDescriptions) {
259 for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
260 vn_replace_VkVertexInputAttributeDescription_handle(&((VkVertexInputAttributeDescription *)val->pVertexAttributeDescriptions)[i]);
261 }
262 }
263
264 static inline void
vn_replace_VkPipelineVertexInputStateCreateInfo_handle(VkPipelineVertexInputStateCreateInfo * val)265 vn_replace_VkPipelineVertexInputStateCreateInfo_handle(VkPipelineVertexInputStateCreateInfo *val)
266 {
267 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
268
269 do {
270 switch ((int32_t)pnext->sType) {
271 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
272 vn_replace_VkPipelineVertexInputStateCreateInfo_handle_self((VkPipelineVertexInputStateCreateInfo *)pnext);
273 break;
274 default:
275 /* ignore unknown/unsupported struct */
276 break;
277 }
278 pnext = pnext->pNext;
279 } while (pnext);
280 }
281
282 /* struct VkPipelineInputAssemblyStateCreateInfo chain */
283
284 static inline void *
vn_decode_VkPipelineInputAssemblyStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)285 vn_decode_VkPipelineInputAssemblyStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
286 {
287 /* no known/supported struct */
288 if (vn_decode_simple_pointer(dec))
289 vn_cs_decoder_set_fatal(dec);
290 return NULL;
291 }
292
293 static inline void
vn_decode_VkPipelineInputAssemblyStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineInputAssemblyStateCreateInfo * val)294 vn_decode_VkPipelineInputAssemblyStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineInputAssemblyStateCreateInfo *val)
295 {
296 /* skip val->{sType,pNext} */
297 vn_decode_VkFlags(dec, &val->flags);
298 vn_decode_VkPrimitiveTopology(dec, &val->topology);
299 vn_decode_VkBool32(dec, &val->primitiveRestartEnable);
300 }
301
302 static inline void
vn_decode_VkPipelineInputAssemblyStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineInputAssemblyStateCreateInfo * val)303 vn_decode_VkPipelineInputAssemblyStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineInputAssemblyStateCreateInfo *val)
304 {
305 VkStructureType stype;
306 vn_decode_VkStructureType(dec, &stype);
307 if (stype != VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO)
308 vn_cs_decoder_set_fatal(dec);
309
310 val->sType = stype;
311 val->pNext = vn_decode_VkPipelineInputAssemblyStateCreateInfo_pnext_temp(dec);
312 vn_decode_VkPipelineInputAssemblyStateCreateInfo_self_temp(dec, val);
313 }
314
315 static inline void
vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle_self(VkPipelineInputAssemblyStateCreateInfo * val)316 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle_self(VkPipelineInputAssemblyStateCreateInfo *val)
317 {
318 /* skip val->sType */
319 /* skip val->pNext */
320 /* skip val->flags */
321 /* skip val->topology */
322 /* skip val->primitiveRestartEnable */
323 }
324
325 static inline void
vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle(VkPipelineInputAssemblyStateCreateInfo * val)326 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle(VkPipelineInputAssemblyStateCreateInfo *val)
327 {
328 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
329
330 do {
331 switch ((int32_t)pnext->sType) {
332 case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
333 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle_self((VkPipelineInputAssemblyStateCreateInfo *)pnext);
334 break;
335 default:
336 /* ignore unknown/unsupported struct */
337 break;
338 }
339 pnext = pnext->pNext;
340 } while (pnext);
341 }
342
343 /* struct VkPipelineTessellationDomainOriginStateCreateInfo chain */
344
345 static inline void *
vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)346 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
347 {
348 /* no known/supported struct */
349 if (vn_decode_simple_pointer(dec))
350 vn_cs_decoder_set_fatal(dec);
351 return NULL;
352 }
353
354 static inline void
vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineTessellationDomainOriginStateCreateInfo * val)355 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineTessellationDomainOriginStateCreateInfo *val)
356 {
357 /* skip val->{sType,pNext} */
358 vn_decode_VkTessellationDomainOrigin(dec, &val->domainOrigin);
359 }
360
361 static inline void
vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineTessellationDomainOriginStateCreateInfo * val)362 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineTessellationDomainOriginStateCreateInfo *val)
363 {
364 VkStructureType stype;
365 vn_decode_VkStructureType(dec, &stype);
366 if (stype != VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO)
367 vn_cs_decoder_set_fatal(dec);
368
369 val->sType = stype;
370 val->pNext = vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext_temp(dec);
371 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(dec, val);
372 }
373
374 static inline void
vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self(VkPipelineTessellationDomainOriginStateCreateInfo * val)375 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self(VkPipelineTessellationDomainOriginStateCreateInfo *val)
376 {
377 /* skip val->sType */
378 /* skip val->pNext */
379 /* skip val->domainOrigin */
380 }
381
382 static inline void
vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle(VkPipelineTessellationDomainOriginStateCreateInfo * val)383 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle(VkPipelineTessellationDomainOriginStateCreateInfo *val)
384 {
385 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
386
387 do {
388 switch ((int32_t)pnext->sType) {
389 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
390 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self((VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
391 break;
392 default:
393 /* ignore unknown/unsupported struct */
394 break;
395 }
396 pnext = pnext->pNext;
397 } while (pnext);
398 }
399
400 /* struct VkPipelineTessellationStateCreateInfo chain */
401
402 static inline void *
vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)403 vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
404 {
405 VkBaseOutStructure *pnext;
406 VkStructureType stype;
407
408 if (!vn_decode_simple_pointer(dec))
409 return NULL;
410
411 vn_decode_VkStructureType(dec, &stype);
412 switch ((int32_t)stype) {
413 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
414 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineTessellationDomainOriginStateCreateInfo));
415 if (pnext) {
416 pnext->sType = stype;
417 pnext->pNext = vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(dec);
418 vn_decode_VkPipelineTessellationDomainOriginStateCreateInfo_self_temp(dec, (VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
419 }
420 break;
421 default:
422 /* unexpected struct */
423 pnext = NULL;
424 vn_cs_decoder_set_fatal(dec);
425 break;
426 }
427
428 return pnext;
429 }
430
431 static inline void
vn_decode_VkPipelineTessellationStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineTessellationStateCreateInfo * val)432 vn_decode_VkPipelineTessellationStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineTessellationStateCreateInfo *val)
433 {
434 /* skip val->{sType,pNext} */
435 vn_decode_VkFlags(dec, &val->flags);
436 vn_decode_uint32_t(dec, &val->patchControlPoints);
437 }
438
439 static inline void
vn_decode_VkPipelineTessellationStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineTessellationStateCreateInfo * val)440 vn_decode_VkPipelineTessellationStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineTessellationStateCreateInfo *val)
441 {
442 VkStructureType stype;
443 vn_decode_VkStructureType(dec, &stype);
444 if (stype != VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO)
445 vn_cs_decoder_set_fatal(dec);
446
447 val->sType = stype;
448 val->pNext = vn_decode_VkPipelineTessellationStateCreateInfo_pnext_temp(dec);
449 vn_decode_VkPipelineTessellationStateCreateInfo_self_temp(dec, val);
450 }
451
452 static inline void
vn_replace_VkPipelineTessellationStateCreateInfo_handle_self(VkPipelineTessellationStateCreateInfo * val)453 vn_replace_VkPipelineTessellationStateCreateInfo_handle_self(VkPipelineTessellationStateCreateInfo *val)
454 {
455 /* skip val->sType */
456 /* skip val->pNext */
457 /* skip val->flags */
458 /* skip val->patchControlPoints */
459 }
460
461 static inline void
vn_replace_VkPipelineTessellationStateCreateInfo_handle(VkPipelineTessellationStateCreateInfo * val)462 vn_replace_VkPipelineTessellationStateCreateInfo_handle(VkPipelineTessellationStateCreateInfo *val)
463 {
464 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
465
466 do {
467 switch ((int32_t)pnext->sType) {
468 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
469 vn_replace_VkPipelineTessellationStateCreateInfo_handle_self((VkPipelineTessellationStateCreateInfo *)pnext);
470 break;
471 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
472 vn_replace_VkPipelineTessellationDomainOriginStateCreateInfo_handle_self((VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
473 break;
474 default:
475 /* ignore unknown/unsupported struct */
476 break;
477 }
478 pnext = pnext->pNext;
479 } while (pnext);
480 }
481
482 /* struct VkPipelineViewportStateCreateInfo chain */
483
484 static inline void *
vn_decode_VkPipelineViewportStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)485 vn_decode_VkPipelineViewportStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
486 {
487 /* no known/supported struct */
488 if (vn_decode_simple_pointer(dec))
489 vn_cs_decoder_set_fatal(dec);
490 return NULL;
491 }
492
493 static inline void
vn_decode_VkPipelineViewportStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineViewportStateCreateInfo * val)494 vn_decode_VkPipelineViewportStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineViewportStateCreateInfo *val)
495 {
496 /* skip val->{sType,pNext} */
497 vn_decode_VkFlags(dec, &val->flags);
498 vn_decode_uint32_t(dec, &val->viewportCount);
499 if (vn_peek_array_size(dec)) {
500 const uint32_t iter_count = vn_decode_array_size(dec, val->viewportCount);
501 val->pViewports = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pViewports) * iter_count);
502 if (!val->pViewports) return;
503 for (uint32_t i = 0; i < iter_count; i++)
504 vn_decode_VkViewport_temp(dec, &((VkViewport *)val->pViewports)[i]);
505 } else {
506 vn_decode_array_size_unchecked(dec);
507 val->pViewports = NULL;
508 }
509 vn_decode_uint32_t(dec, &val->scissorCount);
510 if (vn_peek_array_size(dec)) {
511 const uint32_t iter_count = vn_decode_array_size(dec, val->scissorCount);
512 val->pScissors = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pScissors) * iter_count);
513 if (!val->pScissors) return;
514 for (uint32_t i = 0; i < iter_count; i++)
515 vn_decode_VkRect2D_temp(dec, &((VkRect2D *)val->pScissors)[i]);
516 } else {
517 vn_decode_array_size_unchecked(dec);
518 val->pScissors = NULL;
519 }
520 }
521
522 static inline void
vn_decode_VkPipelineViewportStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineViewportStateCreateInfo * val)523 vn_decode_VkPipelineViewportStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineViewportStateCreateInfo *val)
524 {
525 VkStructureType stype;
526 vn_decode_VkStructureType(dec, &stype);
527 if (stype != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO)
528 vn_cs_decoder_set_fatal(dec);
529
530 val->sType = stype;
531 val->pNext = vn_decode_VkPipelineViewportStateCreateInfo_pnext_temp(dec);
532 vn_decode_VkPipelineViewportStateCreateInfo_self_temp(dec, val);
533 }
534
535 static inline void
vn_replace_VkPipelineViewportStateCreateInfo_handle_self(VkPipelineViewportStateCreateInfo * val)536 vn_replace_VkPipelineViewportStateCreateInfo_handle_self(VkPipelineViewportStateCreateInfo *val)
537 {
538 /* skip val->sType */
539 /* skip val->pNext */
540 /* skip val->flags */
541 /* skip val->viewportCount */
542 if (val->pViewports) {
543 for (uint32_t i = 0; i < val->viewportCount; i++)
544 vn_replace_VkViewport_handle(&((VkViewport *)val->pViewports)[i]);
545 }
546 /* skip val->scissorCount */
547 if (val->pScissors) {
548 for (uint32_t i = 0; i < val->scissorCount; i++)
549 vn_replace_VkRect2D_handle(&((VkRect2D *)val->pScissors)[i]);
550 }
551 }
552
553 static inline void
vn_replace_VkPipelineViewportStateCreateInfo_handle(VkPipelineViewportStateCreateInfo * val)554 vn_replace_VkPipelineViewportStateCreateInfo_handle(VkPipelineViewportStateCreateInfo *val)
555 {
556 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
557
558 do {
559 switch ((int32_t)pnext->sType) {
560 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
561 vn_replace_VkPipelineViewportStateCreateInfo_handle_self((VkPipelineViewportStateCreateInfo *)pnext);
562 break;
563 default:
564 /* ignore unknown/unsupported struct */
565 break;
566 }
567 pnext = pnext->pNext;
568 } while (pnext);
569 }
570
571 /* struct VkPipelineRasterizationStateStreamCreateInfoEXT chain */
572
573 static inline void *
vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)574 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
575 {
576 /* no known/supported struct */
577 if (vn_decode_simple_pointer(dec))
578 vn_cs_decoder_set_fatal(dec);
579 return NULL;
580 }
581
582 static inline void
vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateStreamCreateInfoEXT * val)583 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateStreamCreateInfoEXT *val)
584 {
585 /* skip val->{sType,pNext} */
586 vn_decode_VkFlags(dec, &val->flags);
587 vn_decode_uint32_t(dec, &val->rasterizationStream);
588 }
589
590 static inline void
vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateStreamCreateInfoEXT * val)591 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateStreamCreateInfoEXT *val)
592 {
593 VkStructureType stype;
594 vn_decode_VkStructureType(dec, &stype);
595 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT)
596 vn_cs_decoder_set_fatal(dec);
597
598 val->sType = stype;
599 val->pNext = vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext_temp(dec);
600 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(dec, val);
601 }
602
603 static inline void
vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self(VkPipelineRasterizationStateStreamCreateInfoEXT * val)604 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self(VkPipelineRasterizationStateStreamCreateInfoEXT *val)
605 {
606 /* skip val->sType */
607 /* skip val->pNext */
608 /* skip val->flags */
609 /* skip val->rasterizationStream */
610 }
611
612 static inline void
vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle(VkPipelineRasterizationStateStreamCreateInfoEXT * val)613 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle(VkPipelineRasterizationStateStreamCreateInfoEXT *val)
614 {
615 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
616
617 do {
618 switch ((int32_t)pnext->sType) {
619 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
620 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self((VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
621 break;
622 default:
623 /* ignore unknown/unsupported struct */
624 break;
625 }
626 pnext = pnext->pNext;
627 } while (pnext);
628 }
629
630 /* struct VkPipelineRasterizationStateCreateInfo chain */
631
632 static inline void *
vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)633 vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
634 {
635 VkBaseOutStructure *pnext;
636 VkStructureType stype;
637
638 if (!vn_decode_simple_pointer(dec))
639 return NULL;
640
641 vn_decode_VkStructureType(dec, &stype);
642 switch ((int32_t)stype) {
643 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
644 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT));
645 if (pnext) {
646 pnext->sType = stype;
647 pnext->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
648 vn_decode_VkPipelineRasterizationStateStreamCreateInfoEXT_self_temp(dec, (VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
649 }
650 break;
651 default:
652 /* unexpected struct */
653 pnext = NULL;
654 vn_cs_decoder_set_fatal(dec);
655 break;
656 }
657
658 return pnext;
659 }
660
661 static inline void
vn_decode_VkPipelineRasterizationStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateCreateInfo * val)662 vn_decode_VkPipelineRasterizationStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateCreateInfo *val)
663 {
664 /* skip val->{sType,pNext} */
665 vn_decode_VkFlags(dec, &val->flags);
666 vn_decode_VkBool32(dec, &val->depthClampEnable);
667 vn_decode_VkBool32(dec, &val->rasterizerDiscardEnable);
668 vn_decode_VkPolygonMode(dec, &val->polygonMode);
669 vn_decode_VkFlags(dec, &val->cullMode);
670 vn_decode_VkFrontFace(dec, &val->frontFace);
671 vn_decode_VkBool32(dec, &val->depthBiasEnable);
672 vn_decode_float(dec, &val->depthBiasConstantFactor);
673 vn_decode_float(dec, &val->depthBiasClamp);
674 vn_decode_float(dec, &val->depthBiasSlopeFactor);
675 vn_decode_float(dec, &val->lineWidth);
676 }
677
678 static inline void
vn_decode_VkPipelineRasterizationStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineRasterizationStateCreateInfo * val)679 vn_decode_VkPipelineRasterizationStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineRasterizationStateCreateInfo *val)
680 {
681 VkStructureType stype;
682 vn_decode_VkStructureType(dec, &stype);
683 if (stype != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO)
684 vn_cs_decoder_set_fatal(dec);
685
686 val->sType = stype;
687 val->pNext = vn_decode_VkPipelineRasterizationStateCreateInfo_pnext_temp(dec);
688 vn_decode_VkPipelineRasterizationStateCreateInfo_self_temp(dec, val);
689 }
690
691 static inline void
vn_replace_VkPipelineRasterizationStateCreateInfo_handle_self(VkPipelineRasterizationStateCreateInfo * val)692 vn_replace_VkPipelineRasterizationStateCreateInfo_handle_self(VkPipelineRasterizationStateCreateInfo *val)
693 {
694 /* skip val->sType */
695 /* skip val->pNext */
696 /* skip val->flags */
697 /* skip val->depthClampEnable */
698 /* skip val->rasterizerDiscardEnable */
699 /* skip val->polygonMode */
700 /* skip val->cullMode */
701 /* skip val->frontFace */
702 /* skip val->depthBiasEnable */
703 /* skip val->depthBiasConstantFactor */
704 /* skip val->depthBiasClamp */
705 /* skip val->depthBiasSlopeFactor */
706 /* skip val->lineWidth */
707 }
708
709 static inline void
vn_replace_VkPipelineRasterizationStateCreateInfo_handle(VkPipelineRasterizationStateCreateInfo * val)710 vn_replace_VkPipelineRasterizationStateCreateInfo_handle(VkPipelineRasterizationStateCreateInfo *val)
711 {
712 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
713
714 do {
715 switch ((int32_t)pnext->sType) {
716 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
717 vn_replace_VkPipelineRasterizationStateCreateInfo_handle_self((VkPipelineRasterizationStateCreateInfo *)pnext);
718 break;
719 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
720 vn_replace_VkPipelineRasterizationStateStreamCreateInfoEXT_handle_self((VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
721 break;
722 default:
723 /* ignore unknown/unsupported struct */
724 break;
725 }
726 pnext = pnext->pNext;
727 } while (pnext);
728 }
729
730 /* struct VkPipelineMultisampleStateCreateInfo chain */
731
732 static inline void *
vn_decode_VkPipelineMultisampleStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)733 vn_decode_VkPipelineMultisampleStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
734 {
735 /* no known/supported struct */
736 if (vn_decode_simple_pointer(dec))
737 vn_cs_decoder_set_fatal(dec);
738 return NULL;
739 }
740
741 static inline void
vn_decode_VkPipelineMultisampleStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineMultisampleStateCreateInfo * val)742 vn_decode_VkPipelineMultisampleStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineMultisampleStateCreateInfo *val)
743 {
744 /* skip val->{sType,pNext} */
745 vn_decode_VkFlags(dec, &val->flags);
746 vn_decode_VkSampleCountFlagBits(dec, &val->rasterizationSamples);
747 vn_decode_VkBool32(dec, &val->sampleShadingEnable);
748 vn_decode_float(dec, &val->minSampleShading);
749 if (vn_peek_array_size(dec)) {
750 const size_t array_size = vn_decode_array_size(dec, (val->rasterizationSamples + 31) / 32);
751 val->pSampleMask = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pSampleMask) * array_size);
752 if (!val->pSampleMask) return;
753 vn_decode_VkSampleMask_array(dec, (VkSampleMask *)val->pSampleMask, array_size);
754 } else {
755 vn_decode_array_size_unchecked(dec);
756 val->pSampleMask = NULL;
757 }
758 vn_decode_VkBool32(dec, &val->alphaToCoverageEnable);
759 vn_decode_VkBool32(dec, &val->alphaToOneEnable);
760 }
761
762 static inline void
vn_decode_VkPipelineMultisampleStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineMultisampleStateCreateInfo * val)763 vn_decode_VkPipelineMultisampleStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineMultisampleStateCreateInfo *val)
764 {
765 VkStructureType stype;
766 vn_decode_VkStructureType(dec, &stype);
767 if (stype != VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO)
768 vn_cs_decoder_set_fatal(dec);
769
770 val->sType = stype;
771 val->pNext = vn_decode_VkPipelineMultisampleStateCreateInfo_pnext_temp(dec);
772 vn_decode_VkPipelineMultisampleStateCreateInfo_self_temp(dec, val);
773 }
774
775 static inline void
vn_replace_VkPipelineMultisampleStateCreateInfo_handle_self(VkPipelineMultisampleStateCreateInfo * val)776 vn_replace_VkPipelineMultisampleStateCreateInfo_handle_self(VkPipelineMultisampleStateCreateInfo *val)
777 {
778 /* skip val->sType */
779 /* skip val->pNext */
780 /* skip val->flags */
781 /* skip val->rasterizationSamples */
782 /* skip val->sampleShadingEnable */
783 /* skip val->minSampleShading */
784 /* skip val->pSampleMask */
785 /* skip val->alphaToCoverageEnable */
786 /* skip val->alphaToOneEnable */
787 }
788
789 static inline void
vn_replace_VkPipelineMultisampleStateCreateInfo_handle(VkPipelineMultisampleStateCreateInfo * val)790 vn_replace_VkPipelineMultisampleStateCreateInfo_handle(VkPipelineMultisampleStateCreateInfo *val)
791 {
792 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
793
794 do {
795 switch ((int32_t)pnext->sType) {
796 case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
797 vn_replace_VkPipelineMultisampleStateCreateInfo_handle_self((VkPipelineMultisampleStateCreateInfo *)pnext);
798 break;
799 default:
800 /* ignore unknown/unsupported struct */
801 break;
802 }
803 pnext = pnext->pNext;
804 } while (pnext);
805 }
806
807 /* struct VkStencilOpState */
808
809 static inline void
vn_decode_VkStencilOpState_temp(struct vn_cs_decoder * dec,VkStencilOpState * val)810 vn_decode_VkStencilOpState_temp(struct vn_cs_decoder *dec, VkStencilOpState *val)
811 {
812 vn_decode_VkStencilOp(dec, &val->failOp);
813 vn_decode_VkStencilOp(dec, &val->passOp);
814 vn_decode_VkStencilOp(dec, &val->depthFailOp);
815 vn_decode_VkCompareOp(dec, &val->compareOp);
816 vn_decode_uint32_t(dec, &val->compareMask);
817 vn_decode_uint32_t(dec, &val->writeMask);
818 vn_decode_uint32_t(dec, &val->reference);
819 }
820
821 static inline void
vn_replace_VkStencilOpState_handle(VkStencilOpState * val)822 vn_replace_VkStencilOpState_handle(VkStencilOpState *val)
823 {
824 /* skip val->failOp */
825 /* skip val->passOp */
826 /* skip val->depthFailOp */
827 /* skip val->compareOp */
828 /* skip val->compareMask */
829 /* skip val->writeMask */
830 /* skip val->reference */
831 }
832
833 /* struct VkPipelineDepthStencilStateCreateInfo chain */
834
835 static inline void *
vn_decode_VkPipelineDepthStencilStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)836 vn_decode_VkPipelineDepthStencilStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
837 {
838 /* no known/supported struct */
839 if (vn_decode_simple_pointer(dec))
840 vn_cs_decoder_set_fatal(dec);
841 return NULL;
842 }
843
844 static inline void
vn_decode_VkPipelineDepthStencilStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineDepthStencilStateCreateInfo * val)845 vn_decode_VkPipelineDepthStencilStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateInfo *val)
846 {
847 /* skip val->{sType,pNext} */
848 vn_decode_VkFlags(dec, &val->flags);
849 vn_decode_VkBool32(dec, &val->depthTestEnable);
850 vn_decode_VkBool32(dec, &val->depthWriteEnable);
851 vn_decode_VkCompareOp(dec, &val->depthCompareOp);
852 vn_decode_VkBool32(dec, &val->depthBoundsTestEnable);
853 vn_decode_VkBool32(dec, &val->stencilTestEnable);
854 vn_decode_VkStencilOpState_temp(dec, &val->front);
855 vn_decode_VkStencilOpState_temp(dec, &val->back);
856 vn_decode_float(dec, &val->minDepthBounds);
857 vn_decode_float(dec, &val->maxDepthBounds);
858 }
859
860 static inline void
vn_decode_VkPipelineDepthStencilStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineDepthStencilStateCreateInfo * val)861 vn_decode_VkPipelineDepthStencilStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateInfo *val)
862 {
863 VkStructureType stype;
864 vn_decode_VkStructureType(dec, &stype);
865 if (stype != VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO)
866 vn_cs_decoder_set_fatal(dec);
867
868 val->sType = stype;
869 val->pNext = vn_decode_VkPipelineDepthStencilStateCreateInfo_pnext_temp(dec);
870 vn_decode_VkPipelineDepthStencilStateCreateInfo_self_temp(dec, val);
871 }
872
873 static inline void
vn_replace_VkPipelineDepthStencilStateCreateInfo_handle_self(VkPipelineDepthStencilStateCreateInfo * val)874 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle_self(VkPipelineDepthStencilStateCreateInfo *val)
875 {
876 /* skip val->sType */
877 /* skip val->pNext */
878 /* skip val->flags */
879 /* skip val->depthTestEnable */
880 /* skip val->depthWriteEnable */
881 /* skip val->depthCompareOp */
882 /* skip val->depthBoundsTestEnable */
883 /* skip val->stencilTestEnable */
884 vn_replace_VkStencilOpState_handle(&val->front);
885 vn_replace_VkStencilOpState_handle(&val->back);
886 /* skip val->minDepthBounds */
887 /* skip val->maxDepthBounds */
888 }
889
890 static inline void
vn_replace_VkPipelineDepthStencilStateCreateInfo_handle(VkPipelineDepthStencilStateCreateInfo * val)891 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle(VkPipelineDepthStencilStateCreateInfo *val)
892 {
893 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
894
895 do {
896 switch ((int32_t)pnext->sType) {
897 case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
898 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle_self((VkPipelineDepthStencilStateCreateInfo *)pnext);
899 break;
900 default:
901 /* ignore unknown/unsupported struct */
902 break;
903 }
904 pnext = pnext->pNext;
905 } while (pnext);
906 }
907
908 /* struct VkPipelineColorBlendAttachmentState */
909
910 static inline void
vn_decode_VkPipelineColorBlendAttachmentState_temp(struct vn_cs_decoder * dec,VkPipelineColorBlendAttachmentState * val)911 vn_decode_VkPipelineColorBlendAttachmentState_temp(struct vn_cs_decoder *dec, VkPipelineColorBlendAttachmentState *val)
912 {
913 vn_decode_VkBool32(dec, &val->blendEnable);
914 vn_decode_VkBlendFactor(dec, &val->srcColorBlendFactor);
915 vn_decode_VkBlendFactor(dec, &val->dstColorBlendFactor);
916 vn_decode_VkBlendOp(dec, &val->colorBlendOp);
917 vn_decode_VkBlendFactor(dec, &val->srcAlphaBlendFactor);
918 vn_decode_VkBlendFactor(dec, &val->dstAlphaBlendFactor);
919 vn_decode_VkBlendOp(dec, &val->alphaBlendOp);
920 vn_decode_VkFlags(dec, &val->colorWriteMask);
921 }
922
923 static inline void
vn_replace_VkPipelineColorBlendAttachmentState_handle(VkPipelineColorBlendAttachmentState * val)924 vn_replace_VkPipelineColorBlendAttachmentState_handle(VkPipelineColorBlendAttachmentState *val)
925 {
926 /* skip val->blendEnable */
927 /* skip val->srcColorBlendFactor */
928 /* skip val->dstColorBlendFactor */
929 /* skip val->colorBlendOp */
930 /* skip val->srcAlphaBlendFactor */
931 /* skip val->dstAlphaBlendFactor */
932 /* skip val->alphaBlendOp */
933 /* skip val->colorWriteMask */
934 }
935
936 /* struct VkPipelineColorBlendStateCreateInfo chain */
937
938 static inline void *
vn_decode_VkPipelineColorBlendStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)939 vn_decode_VkPipelineColorBlendStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
940 {
941 /* no known/supported struct */
942 if (vn_decode_simple_pointer(dec))
943 vn_cs_decoder_set_fatal(dec);
944 return NULL;
945 }
946
947 static inline void
vn_decode_VkPipelineColorBlendStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineColorBlendStateCreateInfo * val)948 vn_decode_VkPipelineColorBlendStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateInfo *val)
949 {
950 /* skip val->{sType,pNext} */
951 vn_decode_VkFlags(dec, &val->flags);
952 vn_decode_VkBool32(dec, &val->logicOpEnable);
953 vn_decode_VkLogicOp(dec, &val->logicOp);
954 vn_decode_uint32_t(dec, &val->attachmentCount);
955 if (vn_peek_array_size(dec)) {
956 const uint32_t iter_count = vn_decode_array_size(dec, val->attachmentCount);
957 val->pAttachments = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pAttachments) * iter_count);
958 if (!val->pAttachments) return;
959 for (uint32_t i = 0; i < iter_count; i++)
960 vn_decode_VkPipelineColorBlendAttachmentState_temp(dec, &((VkPipelineColorBlendAttachmentState *)val->pAttachments)[i]);
961 } else {
962 vn_decode_array_size(dec, val->attachmentCount);
963 val->pAttachments = NULL;
964 }
965 {
966 const size_t array_size = vn_decode_array_size(dec, 4);
967 vn_decode_float_array(dec, val->blendConstants, array_size);
968 }
969 }
970
971 static inline void
vn_decode_VkPipelineColorBlendStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineColorBlendStateCreateInfo * val)972 vn_decode_VkPipelineColorBlendStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateInfo *val)
973 {
974 VkStructureType stype;
975 vn_decode_VkStructureType(dec, &stype);
976 if (stype != VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO)
977 vn_cs_decoder_set_fatal(dec);
978
979 val->sType = stype;
980 val->pNext = vn_decode_VkPipelineColorBlendStateCreateInfo_pnext_temp(dec);
981 vn_decode_VkPipelineColorBlendStateCreateInfo_self_temp(dec, val);
982 }
983
984 static inline void
vn_replace_VkPipelineColorBlendStateCreateInfo_handle_self(VkPipelineColorBlendStateCreateInfo * val)985 vn_replace_VkPipelineColorBlendStateCreateInfo_handle_self(VkPipelineColorBlendStateCreateInfo *val)
986 {
987 /* skip val->sType */
988 /* skip val->pNext */
989 /* skip val->flags */
990 /* skip val->logicOpEnable */
991 /* skip val->logicOp */
992 /* skip val->attachmentCount */
993 if (val->pAttachments) {
994 for (uint32_t i = 0; i < val->attachmentCount; i++)
995 vn_replace_VkPipelineColorBlendAttachmentState_handle(&((VkPipelineColorBlendAttachmentState *)val->pAttachments)[i]);
996 }
997 /* skip val->blendConstants */
998 }
999
1000 static inline void
vn_replace_VkPipelineColorBlendStateCreateInfo_handle(VkPipelineColorBlendStateCreateInfo * val)1001 vn_replace_VkPipelineColorBlendStateCreateInfo_handle(VkPipelineColorBlendStateCreateInfo *val)
1002 {
1003 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1004
1005 do {
1006 switch ((int32_t)pnext->sType) {
1007 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
1008 vn_replace_VkPipelineColorBlendStateCreateInfo_handle_self((VkPipelineColorBlendStateCreateInfo *)pnext);
1009 break;
1010 default:
1011 /* ignore unknown/unsupported struct */
1012 break;
1013 }
1014 pnext = pnext->pNext;
1015 } while (pnext);
1016 }
1017
1018 /* struct VkPipelineDynamicStateCreateInfo chain */
1019
1020 static inline void *
vn_decode_VkPipelineDynamicStateCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1021 vn_decode_VkPipelineDynamicStateCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1022 {
1023 /* no known/supported struct */
1024 if (vn_decode_simple_pointer(dec))
1025 vn_cs_decoder_set_fatal(dec);
1026 return NULL;
1027 }
1028
1029 static inline void
vn_decode_VkPipelineDynamicStateCreateInfo_self_temp(struct vn_cs_decoder * dec,VkPipelineDynamicStateCreateInfo * val)1030 vn_decode_VkPipelineDynamicStateCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineDynamicStateCreateInfo *val)
1031 {
1032 /* skip val->{sType,pNext} */
1033 vn_decode_VkFlags(dec, &val->flags);
1034 vn_decode_uint32_t(dec, &val->dynamicStateCount);
1035 if (vn_peek_array_size(dec)) {
1036 const size_t array_size = vn_decode_array_size(dec, val->dynamicStateCount);
1037 val->pDynamicStates = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDynamicStates) * array_size);
1038 if (!val->pDynamicStates) return;
1039 vn_decode_VkDynamicState_array(dec, (VkDynamicState *)val->pDynamicStates, array_size);
1040 } else {
1041 vn_decode_array_size(dec, val->dynamicStateCount);
1042 val->pDynamicStates = NULL;
1043 }
1044 }
1045
1046 static inline void
vn_decode_VkPipelineDynamicStateCreateInfo_temp(struct vn_cs_decoder * dec,VkPipelineDynamicStateCreateInfo * val)1047 vn_decode_VkPipelineDynamicStateCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineDynamicStateCreateInfo *val)
1048 {
1049 VkStructureType stype;
1050 vn_decode_VkStructureType(dec, &stype);
1051 if (stype != VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO)
1052 vn_cs_decoder_set_fatal(dec);
1053
1054 val->sType = stype;
1055 val->pNext = vn_decode_VkPipelineDynamicStateCreateInfo_pnext_temp(dec);
1056 vn_decode_VkPipelineDynamicStateCreateInfo_self_temp(dec, val);
1057 }
1058
1059 static inline void
vn_replace_VkPipelineDynamicStateCreateInfo_handle_self(VkPipelineDynamicStateCreateInfo * val)1060 vn_replace_VkPipelineDynamicStateCreateInfo_handle_self(VkPipelineDynamicStateCreateInfo *val)
1061 {
1062 /* skip val->sType */
1063 /* skip val->pNext */
1064 /* skip val->flags */
1065 /* skip val->dynamicStateCount */
1066 /* skip val->pDynamicStates */
1067 }
1068
1069 static inline void
vn_replace_VkPipelineDynamicStateCreateInfo_handle(VkPipelineDynamicStateCreateInfo * val)1070 vn_replace_VkPipelineDynamicStateCreateInfo_handle(VkPipelineDynamicStateCreateInfo *val)
1071 {
1072 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1073
1074 do {
1075 switch ((int32_t)pnext->sType) {
1076 case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
1077 vn_replace_VkPipelineDynamicStateCreateInfo_handle_self((VkPipelineDynamicStateCreateInfo *)pnext);
1078 break;
1079 default:
1080 /* ignore unknown/unsupported struct */
1081 break;
1082 }
1083 pnext = pnext->pNext;
1084 } while (pnext);
1085 }
1086
1087 /* struct VkGraphicsPipelineCreateInfo chain */
1088
1089 static inline void *
vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1090 vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1091 {
1092 /* no known/supported struct */
1093 if (vn_decode_simple_pointer(dec))
1094 vn_cs_decoder_set_fatal(dec);
1095 return NULL;
1096 }
1097
1098 static inline void
vn_decode_VkGraphicsPipelineCreateInfo_self_temp(struct vn_cs_decoder * dec,VkGraphicsPipelineCreateInfo * val)1099 vn_decode_VkGraphicsPipelineCreateInfo_self_temp(struct vn_cs_decoder *dec, VkGraphicsPipelineCreateInfo *val)
1100 {
1101 /* skip val->{sType,pNext} */
1102 vn_decode_VkFlags(dec, &val->flags);
1103 vn_decode_uint32_t(dec, &val->stageCount);
1104 if (vn_peek_array_size(dec)) {
1105 const uint32_t iter_count = vn_decode_array_size(dec, val->stageCount);
1106 val->pStages = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pStages) * iter_count);
1107 if (!val->pStages) return;
1108 for (uint32_t i = 0; i < iter_count; i++)
1109 vn_decode_VkPipelineShaderStageCreateInfo_temp(dec, &((VkPipelineShaderStageCreateInfo *)val->pStages)[i]);
1110 } else {
1111 vn_decode_array_size(dec, val->stageCount);
1112 val->pStages = NULL;
1113 }
1114 if (vn_decode_simple_pointer(dec)) {
1115 val->pVertexInputState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pVertexInputState));
1116 if (!val->pVertexInputState) return;
1117 vn_decode_VkPipelineVertexInputStateCreateInfo_temp(dec, (VkPipelineVertexInputStateCreateInfo *)val->pVertexInputState);
1118 } else {
1119 val->pVertexInputState = NULL;
1120 }
1121 if (vn_decode_simple_pointer(dec)) {
1122 val->pInputAssemblyState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pInputAssemblyState));
1123 if (!val->pInputAssemblyState) return;
1124 vn_decode_VkPipelineInputAssemblyStateCreateInfo_temp(dec, (VkPipelineInputAssemblyStateCreateInfo *)val->pInputAssemblyState);
1125 } else {
1126 val->pInputAssemblyState = NULL;
1127 }
1128 if (vn_decode_simple_pointer(dec)) {
1129 val->pTessellationState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pTessellationState));
1130 if (!val->pTessellationState) return;
1131 vn_decode_VkPipelineTessellationStateCreateInfo_temp(dec, (VkPipelineTessellationStateCreateInfo *)val->pTessellationState);
1132 } else {
1133 val->pTessellationState = NULL;
1134 }
1135 if (vn_decode_simple_pointer(dec)) {
1136 val->pViewportState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pViewportState));
1137 if (!val->pViewportState) return;
1138 vn_decode_VkPipelineViewportStateCreateInfo_temp(dec, (VkPipelineViewportStateCreateInfo *)val->pViewportState);
1139 } else {
1140 val->pViewportState = NULL;
1141 }
1142 if (vn_decode_simple_pointer(dec)) {
1143 val->pRasterizationState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pRasterizationState));
1144 if (!val->pRasterizationState) return;
1145 vn_decode_VkPipelineRasterizationStateCreateInfo_temp(dec, (VkPipelineRasterizationStateCreateInfo *)val->pRasterizationState);
1146 } else {
1147 val->pRasterizationState = NULL;
1148 vn_cs_decoder_set_fatal(dec);
1149 }
1150 if (vn_decode_simple_pointer(dec)) {
1151 val->pMultisampleState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pMultisampleState));
1152 if (!val->pMultisampleState) return;
1153 vn_decode_VkPipelineMultisampleStateCreateInfo_temp(dec, (VkPipelineMultisampleStateCreateInfo *)val->pMultisampleState);
1154 } else {
1155 val->pMultisampleState = NULL;
1156 }
1157 if (vn_decode_simple_pointer(dec)) {
1158 val->pDepthStencilState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDepthStencilState));
1159 if (!val->pDepthStencilState) return;
1160 vn_decode_VkPipelineDepthStencilStateCreateInfo_temp(dec, (VkPipelineDepthStencilStateCreateInfo *)val->pDepthStencilState);
1161 } else {
1162 val->pDepthStencilState = NULL;
1163 }
1164 if (vn_decode_simple_pointer(dec)) {
1165 val->pColorBlendState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pColorBlendState));
1166 if (!val->pColorBlendState) return;
1167 vn_decode_VkPipelineColorBlendStateCreateInfo_temp(dec, (VkPipelineColorBlendStateCreateInfo *)val->pColorBlendState);
1168 } else {
1169 val->pColorBlendState = NULL;
1170 }
1171 if (vn_decode_simple_pointer(dec)) {
1172 val->pDynamicState = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDynamicState));
1173 if (!val->pDynamicState) return;
1174 vn_decode_VkPipelineDynamicStateCreateInfo_temp(dec, (VkPipelineDynamicStateCreateInfo *)val->pDynamicState);
1175 } else {
1176 val->pDynamicState = NULL;
1177 }
1178 vn_decode_VkPipelineLayout_lookup(dec, &val->layout);
1179 vn_decode_VkRenderPass_lookup(dec, &val->renderPass);
1180 vn_decode_uint32_t(dec, &val->subpass);
1181 vn_decode_VkPipeline_lookup(dec, &val->basePipelineHandle);
1182 vn_decode_int32_t(dec, &val->basePipelineIndex);
1183 }
1184
1185 static inline void
vn_decode_VkGraphicsPipelineCreateInfo_temp(struct vn_cs_decoder * dec,VkGraphicsPipelineCreateInfo * val)1186 vn_decode_VkGraphicsPipelineCreateInfo_temp(struct vn_cs_decoder *dec, VkGraphicsPipelineCreateInfo *val)
1187 {
1188 VkStructureType stype;
1189 vn_decode_VkStructureType(dec, &stype);
1190 if (stype != VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
1191 vn_cs_decoder_set_fatal(dec);
1192
1193 val->sType = stype;
1194 val->pNext = vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(dec);
1195 vn_decode_VkGraphicsPipelineCreateInfo_self_temp(dec, val);
1196 }
1197
1198 static inline void
vn_replace_VkGraphicsPipelineCreateInfo_handle_self(VkGraphicsPipelineCreateInfo * val)1199 vn_replace_VkGraphicsPipelineCreateInfo_handle_self(VkGraphicsPipelineCreateInfo *val)
1200 {
1201 /* skip val->sType */
1202 /* skip val->pNext */
1203 /* skip val->flags */
1204 /* skip val->stageCount */
1205 if (val->pStages) {
1206 for (uint32_t i = 0; i < val->stageCount; i++)
1207 vn_replace_VkPipelineShaderStageCreateInfo_handle(&((VkPipelineShaderStageCreateInfo *)val->pStages)[i]);
1208 }
1209 if (val->pVertexInputState)
1210 vn_replace_VkPipelineVertexInputStateCreateInfo_handle((VkPipelineVertexInputStateCreateInfo *)val->pVertexInputState);
1211 if (val->pInputAssemblyState)
1212 vn_replace_VkPipelineInputAssemblyStateCreateInfo_handle((VkPipelineInputAssemblyStateCreateInfo *)val->pInputAssemblyState);
1213 if (val->pTessellationState)
1214 vn_replace_VkPipelineTessellationStateCreateInfo_handle((VkPipelineTessellationStateCreateInfo *)val->pTessellationState);
1215 if (val->pViewportState)
1216 vn_replace_VkPipelineViewportStateCreateInfo_handle((VkPipelineViewportStateCreateInfo *)val->pViewportState);
1217 if (val->pRasterizationState)
1218 vn_replace_VkPipelineRasterizationStateCreateInfo_handle((VkPipelineRasterizationStateCreateInfo *)val->pRasterizationState);
1219 if (val->pMultisampleState)
1220 vn_replace_VkPipelineMultisampleStateCreateInfo_handle((VkPipelineMultisampleStateCreateInfo *)val->pMultisampleState);
1221 if (val->pDepthStencilState)
1222 vn_replace_VkPipelineDepthStencilStateCreateInfo_handle((VkPipelineDepthStencilStateCreateInfo *)val->pDepthStencilState);
1223 if (val->pColorBlendState)
1224 vn_replace_VkPipelineColorBlendStateCreateInfo_handle((VkPipelineColorBlendStateCreateInfo *)val->pColorBlendState);
1225 if (val->pDynamicState)
1226 vn_replace_VkPipelineDynamicStateCreateInfo_handle((VkPipelineDynamicStateCreateInfo *)val->pDynamicState);
1227 vn_replace_VkPipelineLayout_handle(&val->layout);
1228 vn_replace_VkRenderPass_handle(&val->renderPass);
1229 /* skip val->subpass */
1230 vn_replace_VkPipeline_handle(&val->basePipelineHandle);
1231 /* skip val->basePipelineIndex */
1232 }
1233
1234 static inline void
vn_replace_VkGraphicsPipelineCreateInfo_handle(VkGraphicsPipelineCreateInfo * val)1235 vn_replace_VkGraphicsPipelineCreateInfo_handle(VkGraphicsPipelineCreateInfo *val)
1236 {
1237 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1238
1239 do {
1240 switch ((int32_t)pnext->sType) {
1241 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
1242 vn_replace_VkGraphicsPipelineCreateInfo_handle_self((VkGraphicsPipelineCreateInfo *)pnext);
1243 break;
1244 default:
1245 /* ignore unknown/unsupported struct */
1246 break;
1247 }
1248 pnext = pnext->pNext;
1249 } while (pnext);
1250 }
1251
1252 /* struct VkComputePipelineCreateInfo chain */
1253
1254 static inline void *
vn_decode_VkComputePipelineCreateInfo_pnext_temp(struct vn_cs_decoder * dec)1255 vn_decode_VkComputePipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
1256 {
1257 /* no known/supported struct */
1258 if (vn_decode_simple_pointer(dec))
1259 vn_cs_decoder_set_fatal(dec);
1260 return NULL;
1261 }
1262
1263 static inline void
vn_decode_VkComputePipelineCreateInfo_self_temp(struct vn_cs_decoder * dec,VkComputePipelineCreateInfo * val)1264 vn_decode_VkComputePipelineCreateInfo_self_temp(struct vn_cs_decoder *dec, VkComputePipelineCreateInfo *val)
1265 {
1266 /* skip val->{sType,pNext} */
1267 vn_decode_VkFlags(dec, &val->flags);
1268 vn_decode_VkPipelineShaderStageCreateInfo_temp(dec, &val->stage);
1269 vn_decode_VkPipelineLayout_lookup(dec, &val->layout);
1270 vn_decode_VkPipeline_lookup(dec, &val->basePipelineHandle);
1271 vn_decode_int32_t(dec, &val->basePipelineIndex);
1272 }
1273
1274 static inline void
vn_decode_VkComputePipelineCreateInfo_temp(struct vn_cs_decoder * dec,VkComputePipelineCreateInfo * val)1275 vn_decode_VkComputePipelineCreateInfo_temp(struct vn_cs_decoder *dec, VkComputePipelineCreateInfo *val)
1276 {
1277 VkStructureType stype;
1278 vn_decode_VkStructureType(dec, &stype);
1279 if (stype != VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO)
1280 vn_cs_decoder_set_fatal(dec);
1281
1282 val->sType = stype;
1283 val->pNext = vn_decode_VkComputePipelineCreateInfo_pnext_temp(dec);
1284 vn_decode_VkComputePipelineCreateInfo_self_temp(dec, val);
1285 }
1286
1287 static inline void
vn_replace_VkComputePipelineCreateInfo_handle_self(VkComputePipelineCreateInfo * val)1288 vn_replace_VkComputePipelineCreateInfo_handle_self(VkComputePipelineCreateInfo *val)
1289 {
1290 /* skip val->sType */
1291 /* skip val->pNext */
1292 /* skip val->flags */
1293 vn_replace_VkPipelineShaderStageCreateInfo_handle(&val->stage);
1294 vn_replace_VkPipelineLayout_handle(&val->layout);
1295 vn_replace_VkPipeline_handle(&val->basePipelineHandle);
1296 /* skip val->basePipelineIndex */
1297 }
1298
1299 static inline void
vn_replace_VkComputePipelineCreateInfo_handle(VkComputePipelineCreateInfo * val)1300 vn_replace_VkComputePipelineCreateInfo_handle(VkComputePipelineCreateInfo *val)
1301 {
1302 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
1303
1304 do {
1305 switch ((int32_t)pnext->sType) {
1306 case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
1307 vn_replace_VkComputePipelineCreateInfo_handle_self((VkComputePipelineCreateInfo *)pnext);
1308 break;
1309 default:
1310 /* ignore unknown/unsupported struct */
1311 break;
1312 }
1313 pnext = pnext->pNext;
1314 } while (pnext);
1315 }
1316
vn_decode_vkCreateGraphicsPipelines_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCreateGraphicsPipelines * args)1317 static inline void vn_decode_vkCreateGraphicsPipelines_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreateGraphicsPipelines *args)
1318 {
1319 vn_decode_VkDevice_lookup(dec, &args->device);
1320 vn_decode_VkPipelineCache_lookup(dec, &args->pipelineCache);
1321 vn_decode_uint32_t(dec, &args->createInfoCount);
1322 if (vn_peek_array_size(dec)) {
1323 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
1324 args->pCreateInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfos) * iter_count);
1325 if (!args->pCreateInfos) return;
1326 for (uint32_t i = 0; i < iter_count; i++)
1327 vn_decode_VkGraphicsPipelineCreateInfo_temp(dec, &((VkGraphicsPipelineCreateInfo *)args->pCreateInfos)[i]);
1328 } else {
1329 vn_decode_array_size(dec, args->createInfoCount);
1330 args->pCreateInfos = NULL;
1331 }
1332 if (vn_decode_simple_pointer(dec)) {
1333 vn_cs_decoder_set_fatal(dec);
1334 } else {
1335 args->pAllocator = NULL;
1336 }
1337 if (vn_peek_array_size(dec)) {
1338 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
1339 args->pPipelines = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPipelines) * iter_count);
1340 if (!args->pPipelines) return;
1341 for (uint32_t i = 0; i < iter_count; i++)
1342 vn_decode_VkPipeline(dec, &args->pPipelines[i]);
1343 } else {
1344 vn_decode_array_size(dec, args->createInfoCount);
1345 args->pPipelines = NULL;
1346 }
1347 }
1348
vn_replace_vkCreateGraphicsPipelines_args_handle(struct vn_command_vkCreateGraphicsPipelines * args)1349 static inline void vn_replace_vkCreateGraphicsPipelines_args_handle(struct vn_command_vkCreateGraphicsPipelines *args)
1350 {
1351 vn_replace_VkDevice_handle(&args->device);
1352 vn_replace_VkPipelineCache_handle(&args->pipelineCache);
1353 /* skip args->createInfoCount */
1354 if (args->pCreateInfos) {
1355 for (uint32_t i = 0; i < args->createInfoCount; i++)
1356 vn_replace_VkGraphicsPipelineCreateInfo_handle(&((VkGraphicsPipelineCreateInfo *)args->pCreateInfos)[i]);
1357 }
1358 /* skip args->pAllocator */
1359 /* skip args->pPipelines */
1360 }
1361
vn_encode_vkCreateGraphicsPipelines_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCreateGraphicsPipelines * args)1362 static inline void vn_encode_vkCreateGraphicsPipelines_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreateGraphicsPipelines *args)
1363 {
1364 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT});
1365
1366 vn_encode_VkResult(enc, &args->ret);
1367 /* skip args->device */
1368 /* skip args->pipelineCache */
1369 /* skip args->createInfoCount */
1370 /* skip args->pCreateInfos */
1371 /* skip args->pAllocator */
1372 if (args->pPipelines) {
1373 vn_encode_array_size(enc, args->createInfoCount);
1374 for (uint32_t i = 0; i < args->createInfoCount; i++)
1375 vn_encode_VkPipeline(enc, &args->pPipelines[i]);
1376 } else {
1377 vn_encode_array_size(enc, 0);
1378 }
1379 }
1380
vn_decode_vkCreateComputePipelines_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCreateComputePipelines * args)1381 static inline void vn_decode_vkCreateComputePipelines_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreateComputePipelines *args)
1382 {
1383 vn_decode_VkDevice_lookup(dec, &args->device);
1384 vn_decode_VkPipelineCache_lookup(dec, &args->pipelineCache);
1385 vn_decode_uint32_t(dec, &args->createInfoCount);
1386 if (vn_peek_array_size(dec)) {
1387 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
1388 args->pCreateInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfos) * iter_count);
1389 if (!args->pCreateInfos) return;
1390 for (uint32_t i = 0; i < iter_count; i++)
1391 vn_decode_VkComputePipelineCreateInfo_temp(dec, &((VkComputePipelineCreateInfo *)args->pCreateInfos)[i]);
1392 } else {
1393 vn_decode_array_size(dec, args->createInfoCount);
1394 args->pCreateInfos = NULL;
1395 }
1396 if (vn_decode_simple_pointer(dec)) {
1397 vn_cs_decoder_set_fatal(dec);
1398 } else {
1399 args->pAllocator = NULL;
1400 }
1401 if (vn_peek_array_size(dec)) {
1402 const uint32_t iter_count = vn_decode_array_size(dec, args->createInfoCount);
1403 args->pPipelines = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPipelines) * iter_count);
1404 if (!args->pPipelines) return;
1405 for (uint32_t i = 0; i < iter_count; i++)
1406 vn_decode_VkPipeline(dec, &args->pPipelines[i]);
1407 } else {
1408 vn_decode_array_size(dec, args->createInfoCount);
1409 args->pPipelines = NULL;
1410 }
1411 }
1412
vn_replace_vkCreateComputePipelines_args_handle(struct vn_command_vkCreateComputePipelines * args)1413 static inline void vn_replace_vkCreateComputePipelines_args_handle(struct vn_command_vkCreateComputePipelines *args)
1414 {
1415 vn_replace_VkDevice_handle(&args->device);
1416 vn_replace_VkPipelineCache_handle(&args->pipelineCache);
1417 /* skip args->createInfoCount */
1418 if (args->pCreateInfos) {
1419 for (uint32_t i = 0; i < args->createInfoCount; i++)
1420 vn_replace_VkComputePipelineCreateInfo_handle(&((VkComputePipelineCreateInfo *)args->pCreateInfos)[i]);
1421 }
1422 /* skip args->pAllocator */
1423 /* skip args->pPipelines */
1424 }
1425
vn_encode_vkCreateComputePipelines_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCreateComputePipelines * args)1426 static inline void vn_encode_vkCreateComputePipelines_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreateComputePipelines *args)
1427 {
1428 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreateComputePipelines_EXT});
1429
1430 vn_encode_VkResult(enc, &args->ret);
1431 /* skip args->device */
1432 /* skip args->pipelineCache */
1433 /* skip args->createInfoCount */
1434 /* skip args->pCreateInfos */
1435 /* skip args->pAllocator */
1436 if (args->pPipelines) {
1437 vn_encode_array_size(enc, args->createInfoCount);
1438 for (uint32_t i = 0; i < args->createInfoCount; i++)
1439 vn_encode_VkPipeline(enc, &args->pPipelines[i]);
1440 } else {
1441 vn_encode_array_size(enc, 0);
1442 }
1443 }
1444
vn_decode_vkDestroyPipeline_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkDestroyPipeline * args)1445 static inline void vn_decode_vkDestroyPipeline_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkDestroyPipeline *args)
1446 {
1447 vn_decode_VkDevice_lookup(dec, &args->device);
1448 vn_decode_VkPipeline_lookup(dec, &args->pipeline);
1449 if (vn_decode_simple_pointer(dec)) {
1450 vn_cs_decoder_set_fatal(dec);
1451 } else {
1452 args->pAllocator = NULL;
1453 }
1454 }
1455
vn_replace_vkDestroyPipeline_args_handle(struct vn_command_vkDestroyPipeline * args)1456 static inline void vn_replace_vkDestroyPipeline_args_handle(struct vn_command_vkDestroyPipeline *args)
1457 {
1458 vn_replace_VkDevice_handle(&args->device);
1459 vn_replace_VkPipeline_handle(&args->pipeline);
1460 /* skip args->pAllocator */
1461 }
1462
vn_encode_vkDestroyPipeline_reply(struct vn_cs_encoder * enc,const struct vn_command_vkDestroyPipeline * args)1463 static inline void vn_encode_vkDestroyPipeline_reply(struct vn_cs_encoder *enc, const struct vn_command_vkDestroyPipeline *args)
1464 {
1465 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkDestroyPipeline_EXT});
1466
1467 /* skip args->device */
1468 /* skip args->pipeline */
1469 /* skip args->pAllocator */
1470 }
1471
vn_dispatch_vkCreateGraphicsPipelines(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1472 static inline void vn_dispatch_vkCreateGraphicsPipelines(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1473 {
1474 struct vn_command_vkCreateGraphicsPipelines args;
1475
1476 if (!ctx->dispatch_vkCreateGraphicsPipelines) {
1477 vn_cs_decoder_set_fatal(ctx->decoder);
1478 return;
1479 }
1480
1481 vn_decode_vkCreateGraphicsPipelines_args_temp(ctx->decoder, &args);
1482 if (!args.device) {
1483 vn_cs_decoder_set_fatal(ctx->decoder);
1484 return;
1485 }
1486
1487 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1488 ctx->dispatch_vkCreateGraphicsPipelines(ctx, &args);
1489
1490 #ifdef DEBUG
1491 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1492 vn_dispatch_debug_log(ctx, "vkCreateGraphicsPipelines returned %d", args.ret);
1493 #endif
1494
1495 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1496 vn_encode_vkCreateGraphicsPipelines_reply(ctx->encoder, &args);
1497
1498 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1499 }
1500
vn_dispatch_vkCreateComputePipelines(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1501 static inline void vn_dispatch_vkCreateComputePipelines(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1502 {
1503 struct vn_command_vkCreateComputePipelines args;
1504
1505 if (!ctx->dispatch_vkCreateComputePipelines) {
1506 vn_cs_decoder_set_fatal(ctx->decoder);
1507 return;
1508 }
1509
1510 vn_decode_vkCreateComputePipelines_args_temp(ctx->decoder, &args);
1511 if (!args.device) {
1512 vn_cs_decoder_set_fatal(ctx->decoder);
1513 return;
1514 }
1515
1516 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1517 ctx->dispatch_vkCreateComputePipelines(ctx, &args);
1518
1519 #ifdef DEBUG
1520 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1521 vn_dispatch_debug_log(ctx, "vkCreateComputePipelines returned %d", args.ret);
1522 #endif
1523
1524 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1525 vn_encode_vkCreateComputePipelines_reply(ctx->encoder, &args);
1526
1527 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1528 }
1529
vn_dispatch_vkDestroyPipeline(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1530 static inline void vn_dispatch_vkDestroyPipeline(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1531 {
1532 struct vn_command_vkDestroyPipeline args;
1533
1534 if (!ctx->dispatch_vkDestroyPipeline) {
1535 vn_cs_decoder_set_fatal(ctx->decoder);
1536 return;
1537 }
1538
1539 vn_decode_vkDestroyPipeline_args_temp(ctx->decoder, &args);
1540 if (!args.device) {
1541 vn_cs_decoder_set_fatal(ctx->decoder);
1542 return;
1543 }
1544
1545 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1546 ctx->dispatch_vkDestroyPipeline(ctx, &args);
1547
1548
1549 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1550 vn_encode_vkDestroyPipeline_reply(ctx->encoder, &args);
1551
1552 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1553 }
1554
1555 #pragma GCC diagnostic pop
1556
1557 #endif /* VN_PROTOCOL_RENDERER_PIPELINE_H */
1558