1 /* This file is generated by venus-protocol. See vn_protocol_driver.h. */
2
3 /*
4 * Copyright 2020 Google LLC
5 * SPDX-License-Identifier: MIT
6 */
7
8 #ifndef VN_PROTOCOL_DRIVER_PIPELINE_H
9 #define VN_PROTOCOL_DRIVER_PIPELINE_H
10
11 #include "vn_ring.h"
12 #include "vn_protocol_driver_structs.h"
13
14 /* struct VkSpecializationMapEntry */
15
16 static inline size_t
vn_sizeof_VkSpecializationMapEntry(const VkSpecializationMapEntry * val)17 vn_sizeof_VkSpecializationMapEntry(const VkSpecializationMapEntry *val)
18 {
19 size_t size = 0;
20 size += vn_sizeof_uint32_t(&val->constantID);
21 size += vn_sizeof_uint32_t(&val->offset);
22 size += vn_sizeof_size_t(&val->size);
23 return size;
24 }
25
26 static inline void
vn_encode_VkSpecializationMapEntry(struct vn_cs_encoder * enc,const VkSpecializationMapEntry * val)27 vn_encode_VkSpecializationMapEntry(struct vn_cs_encoder *enc, const VkSpecializationMapEntry *val)
28 {
29 vn_encode_uint32_t(enc, &val->constantID);
30 vn_encode_uint32_t(enc, &val->offset);
31 vn_encode_size_t(enc, &val->size);
32 }
33
34 /* struct VkSpecializationInfo */
35
36 static inline size_t
vn_sizeof_VkSpecializationInfo(const VkSpecializationInfo * val)37 vn_sizeof_VkSpecializationInfo(const VkSpecializationInfo *val)
38 {
39 size_t size = 0;
40 size += vn_sizeof_uint32_t(&val->mapEntryCount);
41 if (val->pMapEntries) {
42 size += vn_sizeof_array_size(val->mapEntryCount);
43 for (uint32_t i = 0; i < val->mapEntryCount; i++)
44 size += vn_sizeof_VkSpecializationMapEntry(&val->pMapEntries[i]);
45 } else {
46 size += vn_sizeof_array_size(0);
47 }
48 size += vn_sizeof_size_t(&val->dataSize);
49 if (val->pData) {
50 size += vn_sizeof_array_size(val->dataSize);
51 size += vn_sizeof_blob_array(val->pData, val->dataSize);
52 } else {
53 size += vn_sizeof_array_size(0);
54 }
55 return size;
56 }
57
58 static inline void
vn_encode_VkSpecializationInfo(struct vn_cs_encoder * enc,const VkSpecializationInfo * val)59 vn_encode_VkSpecializationInfo(struct vn_cs_encoder *enc, const VkSpecializationInfo *val)
60 {
61 vn_encode_uint32_t(enc, &val->mapEntryCount);
62 if (val->pMapEntries) {
63 vn_encode_array_size(enc, val->mapEntryCount);
64 for (uint32_t i = 0; i < val->mapEntryCount; i++)
65 vn_encode_VkSpecializationMapEntry(enc, &val->pMapEntries[i]);
66 } else {
67 vn_encode_array_size(enc, 0);
68 }
69 vn_encode_size_t(enc, &val->dataSize);
70 if (val->pData) {
71 vn_encode_array_size(enc, val->dataSize);
72 vn_encode_blob_array(enc, val->pData, val->dataSize);
73 } else {
74 vn_encode_array_size(enc, 0);
75 }
76 }
77
78 /* struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo chain */
79
80 static inline size_t
vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(const void * val)81 vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(const void *val)
82 {
83 /* no known/supported struct */
84 return vn_sizeof_simple_pointer(NULL);
85 }
86
87 static inline size_t
vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)88 vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
89 {
90 size_t size = 0;
91 /* skip val->{sType,pNext} */
92 size += vn_sizeof_uint32_t(&val->requiredSubgroupSize);
93 return size;
94 }
95
96 static inline size_t
vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)97 vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
98 {
99 size_t size = 0;
100
101 size += vn_sizeof_VkStructureType(&val->sType);
102 size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(val->pNext);
103 size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(val);
104
105 return size;
106 }
107
108 static inline void
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)109 vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
110 {
111 /* no known/supported struct */
112 vn_encode_simple_pointer(enc, NULL);
113 }
114
115 static inline void
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)116 vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
117 {
118 /* skip val->{sType,pNext} */
119 vn_encode_uint32_t(enc, &val->requiredSubgroupSize);
120 }
121
122 static inline void
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(struct vn_cs_encoder * enc,const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo * val)123 vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
124 {
125 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO);
126 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO });
127 vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(enc, val->pNext);
128 vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(enc, val);
129 }
130
131 /* struct VkPipelineShaderStageCreateInfo chain */
132
133 static inline size_t
vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(const void * val)134 vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(const void *val)
135 {
136 const VkBaseInStructure *pnext = val;
137 size_t size = 0;
138
139 while (pnext) {
140 switch ((int32_t)pnext->sType) {
141 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
142 size += vn_sizeof_simple_pointer(pnext);
143 size += vn_sizeof_VkStructureType(&pnext->sType);
144 size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(pnext->pNext);
145 size += vn_sizeof_VkShaderModuleCreateInfo_self((const VkShaderModuleCreateInfo *)pnext);
146 return size;
147 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
148 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
149 break;
150 size += vn_sizeof_simple_pointer(pnext);
151 size += vn_sizeof_VkStructureType(&pnext->sType);
152 size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(pnext->pNext);
153 size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self((const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
154 return size;
155 default:
156 /* ignore unknown/unsupported struct */
157 break;
158 }
159 pnext = pnext->pNext;
160 }
161
162 return vn_sizeof_simple_pointer(NULL);
163 }
164
165 static inline size_t
vn_sizeof_VkPipelineShaderStageCreateInfo_self(const VkPipelineShaderStageCreateInfo * val)166 vn_sizeof_VkPipelineShaderStageCreateInfo_self(const VkPipelineShaderStageCreateInfo *val)
167 {
168 size_t size = 0;
169 /* skip val->{sType,pNext} */
170 size += vn_sizeof_VkFlags(&val->flags);
171 size += vn_sizeof_VkShaderStageFlagBits(&val->stage);
172 size += vn_sizeof_VkShaderModule(&val->module);
173 if (val->pName) {
174 const size_t string_size = strlen(val->pName) + 1;
175 size += vn_sizeof_array_size(string_size);
176 size += vn_sizeof_char_array(val->pName, string_size);
177 } else {
178 size += vn_sizeof_array_size(0);
179 }
180 size += vn_sizeof_simple_pointer(val->pSpecializationInfo);
181 if (val->pSpecializationInfo)
182 size += vn_sizeof_VkSpecializationInfo(val->pSpecializationInfo);
183 return size;
184 }
185
186 static inline size_t
vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo * val)187 vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo *val)
188 {
189 size_t size = 0;
190
191 size += vn_sizeof_VkStructureType(&val->sType);
192 size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(val->pNext);
193 size += vn_sizeof_VkPipelineShaderStageCreateInfo_self(val);
194
195 return size;
196 }
197
198 static inline void
vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)199 vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
200 {
201 const VkBaseInStructure *pnext = val;
202
203 while (pnext) {
204 switch ((int32_t)pnext->sType) {
205 case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
206 vn_encode_simple_pointer(enc, pnext);
207 vn_encode_VkStructureType(enc, &pnext->sType);
208 vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, pnext->pNext);
209 vn_encode_VkShaderModuleCreateInfo_self(enc, (const VkShaderModuleCreateInfo *)pnext);
210 return;
211 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
212 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
213 break;
214 vn_encode_simple_pointer(enc, pnext);
215 vn_encode_VkStructureType(enc, &pnext->sType);
216 vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, pnext->pNext);
217 vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(enc, (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
218 return;
219 default:
220 /* ignore unknown/unsupported struct */
221 break;
222 }
223 pnext = pnext->pNext;
224 }
225
226 vn_encode_simple_pointer(enc, NULL);
227 }
228
229 static inline void
vn_encode_VkPipelineShaderStageCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineShaderStageCreateInfo * val)230 vn_encode_VkPipelineShaderStageCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
231 {
232 /* skip val->{sType,pNext} */
233 vn_encode_VkFlags(enc, &val->flags);
234 vn_encode_VkShaderStageFlagBits(enc, &val->stage);
235 vn_encode_VkShaderModule(enc, &val->module);
236 if (val->pName) {
237 const size_t string_size = strlen(val->pName) + 1;
238 vn_encode_array_size(enc, string_size);
239 vn_encode_char_array(enc, val->pName, string_size);
240 } else {
241 vn_encode_array_size(enc, 0);
242 }
243 if (vn_encode_simple_pointer(enc, val->pSpecializationInfo))
244 vn_encode_VkSpecializationInfo(enc, val->pSpecializationInfo);
245 }
246
247 static inline void
vn_encode_VkPipelineShaderStageCreateInfo(struct vn_cs_encoder * enc,const VkPipelineShaderStageCreateInfo * val)248 vn_encode_VkPipelineShaderStageCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
249 {
250 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO);
251 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO });
252 vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, val->pNext);
253 vn_encode_VkPipelineShaderStageCreateInfo_self(enc, val);
254 }
255
256 /* struct VkVertexInputBindingDescription */
257
258 static inline size_t
vn_sizeof_VkVertexInputBindingDescription(const VkVertexInputBindingDescription * val)259 vn_sizeof_VkVertexInputBindingDescription(const VkVertexInputBindingDescription *val)
260 {
261 size_t size = 0;
262 size += vn_sizeof_uint32_t(&val->binding);
263 size += vn_sizeof_uint32_t(&val->stride);
264 size += vn_sizeof_VkVertexInputRate(&val->inputRate);
265 return size;
266 }
267
268 static inline void
vn_encode_VkVertexInputBindingDescription(struct vn_cs_encoder * enc,const VkVertexInputBindingDescription * val)269 vn_encode_VkVertexInputBindingDescription(struct vn_cs_encoder *enc, const VkVertexInputBindingDescription *val)
270 {
271 vn_encode_uint32_t(enc, &val->binding);
272 vn_encode_uint32_t(enc, &val->stride);
273 vn_encode_VkVertexInputRate(enc, &val->inputRate);
274 }
275
276 /* struct VkVertexInputAttributeDescription */
277
278 static inline size_t
vn_sizeof_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription * val)279 vn_sizeof_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription *val)
280 {
281 size_t size = 0;
282 size += vn_sizeof_uint32_t(&val->location);
283 size += vn_sizeof_uint32_t(&val->binding);
284 size += vn_sizeof_VkFormat(&val->format);
285 size += vn_sizeof_uint32_t(&val->offset);
286 return size;
287 }
288
289 static inline void
vn_encode_VkVertexInputAttributeDescription(struct vn_cs_encoder * enc,const VkVertexInputAttributeDescription * val)290 vn_encode_VkVertexInputAttributeDescription(struct vn_cs_encoder *enc, const VkVertexInputAttributeDescription *val)
291 {
292 vn_encode_uint32_t(enc, &val->location);
293 vn_encode_uint32_t(enc, &val->binding);
294 vn_encode_VkFormat(enc, &val->format);
295 vn_encode_uint32_t(enc, &val->offset);
296 }
297
298 /* struct VkVertexInputBindingDivisorDescriptionEXT */
299
300 static inline size_t
vn_sizeof_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT * val)301 vn_sizeof_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT *val)
302 {
303 size_t size = 0;
304 size += vn_sizeof_uint32_t(&val->binding);
305 size += vn_sizeof_uint32_t(&val->divisor);
306 return size;
307 }
308
309 static inline void
vn_encode_VkVertexInputBindingDivisorDescriptionEXT(struct vn_cs_encoder * enc,const VkVertexInputBindingDivisorDescriptionEXT * val)310 vn_encode_VkVertexInputBindingDivisorDescriptionEXT(struct vn_cs_encoder *enc, const VkVertexInputBindingDivisorDescriptionEXT *val)
311 {
312 vn_encode_uint32_t(enc, &val->binding);
313 vn_encode_uint32_t(enc, &val->divisor);
314 }
315
316 /* struct VkPipelineVertexInputDivisorStateCreateInfoEXT chain */
317
318 static inline size_t
vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(const void * val)319 vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(const void *val)
320 {
321 /* no known/supported struct */
322 return vn_sizeof_simple_pointer(NULL);
323 }
324
325 static inline size_t
vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)326 vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
327 {
328 size_t size = 0;
329 /* skip val->{sType,pNext} */
330 size += vn_sizeof_uint32_t(&val->vertexBindingDivisorCount);
331 if (val->pVertexBindingDivisors) {
332 size += vn_sizeof_array_size(val->vertexBindingDivisorCount);
333 for (uint32_t i = 0; i < val->vertexBindingDivisorCount; i++)
334 size += vn_sizeof_VkVertexInputBindingDivisorDescriptionEXT(&val->pVertexBindingDivisors[i]);
335 } else {
336 size += vn_sizeof_array_size(0);
337 }
338 return size;
339 }
340
341 static inline size_t
vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)342 vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
343 {
344 size_t size = 0;
345
346 size += vn_sizeof_VkStructureType(&val->sType);
347 size += vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(val->pNext);
348 size += vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(val);
349
350 return size;
351 }
352
353 static inline void
vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)354 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
355 {
356 /* no known/supported struct */
357 vn_encode_simple_pointer(enc, NULL);
358 }
359
360 static inline void
vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)361 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
362 {
363 /* skip val->{sType,pNext} */
364 vn_encode_uint32_t(enc, &val->vertexBindingDivisorCount);
365 if (val->pVertexBindingDivisors) {
366 vn_encode_array_size(enc, val->vertexBindingDivisorCount);
367 for (uint32_t i = 0; i < val->vertexBindingDivisorCount; i++)
368 vn_encode_VkVertexInputBindingDivisorDescriptionEXT(enc, &val->pVertexBindingDivisors[i]);
369 } else {
370 vn_encode_array_size(enc, 0);
371 }
372 }
373
374 static inline void
vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)375 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
376 {
377 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT);
378 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT });
379 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(enc, val->pNext);
380 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(enc, val);
381 }
382
383 /* struct VkPipelineVertexInputStateCreateInfo chain */
384
385 static inline size_t
vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(const void * val)386 vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(const void *val)
387 {
388 const VkBaseInStructure *pnext = val;
389 size_t size = 0;
390
391 while (pnext) {
392 switch ((int32_t)pnext->sType) {
393 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
394 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
395 break;
396 size += vn_sizeof_simple_pointer(pnext);
397 size += vn_sizeof_VkStructureType(&pnext->sType);
398 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(pnext->pNext);
399 size += vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self((const VkPipelineVertexInputDivisorStateCreateInfoEXT *)pnext);
400 return size;
401 default:
402 /* ignore unknown/unsupported struct */
403 break;
404 }
405 pnext = pnext->pNext;
406 }
407
408 return vn_sizeof_simple_pointer(NULL);
409 }
410
411 static inline size_t
vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(const VkPipelineVertexInputStateCreateInfo * val)412 vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(const VkPipelineVertexInputStateCreateInfo *val)
413 {
414 size_t size = 0;
415 /* skip val->{sType,pNext} */
416 size += vn_sizeof_VkFlags(&val->flags);
417 size += vn_sizeof_uint32_t(&val->vertexBindingDescriptionCount);
418 if (val->pVertexBindingDescriptions) {
419 size += vn_sizeof_array_size(val->vertexBindingDescriptionCount);
420 for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
421 size += vn_sizeof_VkVertexInputBindingDescription(&val->pVertexBindingDescriptions[i]);
422 } else {
423 size += vn_sizeof_array_size(0);
424 }
425 size += vn_sizeof_uint32_t(&val->vertexAttributeDescriptionCount);
426 if (val->pVertexAttributeDescriptions) {
427 size += vn_sizeof_array_size(val->vertexAttributeDescriptionCount);
428 for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
429 size += vn_sizeof_VkVertexInputAttributeDescription(&val->pVertexAttributeDescriptions[i]);
430 } else {
431 size += vn_sizeof_array_size(0);
432 }
433 return size;
434 }
435
436 static inline size_t
vn_sizeof_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo * val)437 vn_sizeof_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo *val)
438 {
439 size_t size = 0;
440
441 size += vn_sizeof_VkStructureType(&val->sType);
442 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(val->pNext);
443 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(val);
444
445 return size;
446 }
447
448 static inline void
vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)449 vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
450 {
451 const VkBaseInStructure *pnext = val;
452
453 while (pnext) {
454 switch ((int32_t)pnext->sType) {
455 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
456 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
457 break;
458 vn_encode_simple_pointer(enc, pnext);
459 vn_encode_VkStructureType(enc, &pnext->sType);
460 vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(enc, pnext->pNext);
461 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(enc, (const VkPipelineVertexInputDivisorStateCreateInfoEXT *)pnext);
462 return;
463 default:
464 /* ignore unknown/unsupported struct */
465 break;
466 }
467 pnext = pnext->pNext;
468 }
469
470 vn_encode_simple_pointer(enc, NULL);
471 }
472
473 static inline void
vn_encode_VkPipelineVertexInputStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineVertexInputStateCreateInfo * val)474 vn_encode_VkPipelineVertexInputStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
475 {
476 /* skip val->{sType,pNext} */
477 vn_encode_VkFlags(enc, &val->flags);
478 vn_encode_uint32_t(enc, &val->vertexBindingDescriptionCount);
479 if (val->pVertexBindingDescriptions) {
480 vn_encode_array_size(enc, val->vertexBindingDescriptionCount);
481 for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
482 vn_encode_VkVertexInputBindingDescription(enc, &val->pVertexBindingDescriptions[i]);
483 } else {
484 vn_encode_array_size(enc, 0);
485 }
486 vn_encode_uint32_t(enc, &val->vertexAttributeDescriptionCount);
487 if (val->pVertexAttributeDescriptions) {
488 vn_encode_array_size(enc, val->vertexAttributeDescriptionCount);
489 for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
490 vn_encode_VkVertexInputAttributeDescription(enc, &val->pVertexAttributeDescriptions[i]);
491 } else {
492 vn_encode_array_size(enc, 0);
493 }
494 }
495
496 static inline void
vn_encode_VkPipelineVertexInputStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineVertexInputStateCreateInfo * val)497 vn_encode_VkPipelineVertexInputStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
498 {
499 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO);
500 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO });
501 vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(enc, val->pNext);
502 vn_encode_VkPipelineVertexInputStateCreateInfo_self(enc, val);
503 }
504
505 /* struct VkPipelineInputAssemblyStateCreateInfo chain */
506
507 static inline size_t
vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(const void * val)508 vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(const void *val)
509 {
510 /* no known/supported struct */
511 return vn_sizeof_simple_pointer(NULL);
512 }
513
514 static inline size_t
vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(const VkPipelineInputAssemblyStateCreateInfo * val)515 vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(const VkPipelineInputAssemblyStateCreateInfo *val)
516 {
517 size_t size = 0;
518 /* skip val->{sType,pNext} */
519 size += vn_sizeof_VkFlags(&val->flags);
520 size += vn_sizeof_VkPrimitiveTopology(&val->topology);
521 size += vn_sizeof_VkBool32(&val->primitiveRestartEnable);
522 return size;
523 }
524
525 static inline size_t
vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo * val)526 vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo *val)
527 {
528 size_t size = 0;
529
530 size += vn_sizeof_VkStructureType(&val->sType);
531 size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(val->pNext);
532 size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(val);
533
534 return size;
535 }
536
537 static inline void
vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)538 vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
539 {
540 /* no known/supported struct */
541 vn_encode_simple_pointer(enc, NULL);
542 }
543
544 static inline void
vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineInputAssemblyStateCreateInfo * val)545 vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
546 {
547 /* skip val->{sType,pNext} */
548 vn_encode_VkFlags(enc, &val->flags);
549 vn_encode_VkPrimitiveTopology(enc, &val->topology);
550 vn_encode_VkBool32(enc, &val->primitiveRestartEnable);
551 }
552
553 static inline void
vn_encode_VkPipelineInputAssemblyStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineInputAssemblyStateCreateInfo * val)554 vn_encode_VkPipelineInputAssemblyStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
555 {
556 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO);
557 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO });
558 vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(enc, val->pNext);
559 vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(enc, val);
560 }
561
562 /* struct VkPipelineTessellationDomainOriginStateCreateInfo chain */
563
564 static inline size_t
vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(const void * val)565 vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(const void *val)
566 {
567 /* no known/supported struct */
568 return vn_sizeof_simple_pointer(NULL);
569 }
570
571 static inline size_t
vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(const VkPipelineTessellationDomainOriginStateCreateInfo * val)572 vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
573 {
574 size_t size = 0;
575 /* skip val->{sType,pNext} */
576 size += vn_sizeof_VkTessellationDomainOrigin(&val->domainOrigin);
577 return size;
578 }
579
580 static inline size_t
vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo * val)581 vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
582 {
583 size_t size = 0;
584
585 size += vn_sizeof_VkStructureType(&val->sType);
586 size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(val->pNext);
587 size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(val);
588
589 return size;
590 }
591
592 static inline void
vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)593 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
594 {
595 /* no known/supported struct */
596 vn_encode_simple_pointer(enc, NULL);
597 }
598
599 static inline void
vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineTessellationDomainOriginStateCreateInfo * val)600 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
601 {
602 /* skip val->{sType,pNext} */
603 vn_encode_VkTessellationDomainOrigin(enc, &val->domainOrigin);
604 }
605
606 static inline void
vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineTessellationDomainOriginStateCreateInfo * val)607 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
608 {
609 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO);
610 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO });
611 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(enc, val->pNext);
612 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, val);
613 }
614
615 /* struct VkPipelineTessellationStateCreateInfo chain */
616
617 static inline size_t
vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(const void * val)618 vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(const void *val)
619 {
620 const VkBaseInStructure *pnext = val;
621 size_t size = 0;
622
623 while (pnext) {
624 switch ((int32_t)pnext->sType) {
625 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
626 size += vn_sizeof_simple_pointer(pnext);
627 size += vn_sizeof_VkStructureType(&pnext->sType);
628 size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(pnext->pNext);
629 size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self((const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
630 return size;
631 default:
632 /* ignore unknown/unsupported struct */
633 break;
634 }
635 pnext = pnext->pNext;
636 }
637
638 return vn_sizeof_simple_pointer(NULL);
639 }
640
641 static inline size_t
vn_sizeof_VkPipelineTessellationStateCreateInfo_self(const VkPipelineTessellationStateCreateInfo * val)642 vn_sizeof_VkPipelineTessellationStateCreateInfo_self(const VkPipelineTessellationStateCreateInfo *val)
643 {
644 size_t size = 0;
645 /* skip val->{sType,pNext} */
646 size += vn_sizeof_VkFlags(&val->flags);
647 size += vn_sizeof_uint32_t(&val->patchControlPoints);
648 return size;
649 }
650
651 static inline size_t
vn_sizeof_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo * val)652 vn_sizeof_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo *val)
653 {
654 size_t size = 0;
655
656 size += vn_sizeof_VkStructureType(&val->sType);
657 size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(val->pNext);
658 size += vn_sizeof_VkPipelineTessellationStateCreateInfo_self(val);
659
660 return size;
661 }
662
663 static inline void
vn_encode_VkPipelineTessellationStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)664 vn_encode_VkPipelineTessellationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
665 {
666 const VkBaseInStructure *pnext = val;
667
668 while (pnext) {
669 switch ((int32_t)pnext->sType) {
670 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
671 vn_encode_simple_pointer(enc, pnext);
672 vn_encode_VkStructureType(enc, &pnext->sType);
673 vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, pnext->pNext);
674 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, (const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
675 return;
676 default:
677 /* ignore unknown/unsupported struct */
678 break;
679 }
680 pnext = pnext->pNext;
681 }
682
683 vn_encode_simple_pointer(enc, NULL);
684 }
685
686 static inline void
vn_encode_VkPipelineTessellationStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineTessellationStateCreateInfo * val)687 vn_encode_VkPipelineTessellationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
688 {
689 /* skip val->{sType,pNext} */
690 vn_encode_VkFlags(enc, &val->flags);
691 vn_encode_uint32_t(enc, &val->patchControlPoints);
692 }
693
694 static inline void
vn_encode_VkPipelineTessellationStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineTessellationStateCreateInfo * val)695 vn_encode_VkPipelineTessellationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
696 {
697 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO);
698 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO });
699 vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, val->pNext);
700 vn_encode_VkPipelineTessellationStateCreateInfo_self(enc, val);
701 }
702
703 /* struct VkPipelineViewportDepthClipControlCreateInfoEXT chain */
704
705 static inline size_t
vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext(const void * val)706 vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext(const void *val)
707 {
708 /* no known/supported struct */
709 return vn_sizeof_simple_pointer(NULL);
710 }
711
712 static inline size_t
vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT_self(const VkPipelineViewportDepthClipControlCreateInfoEXT * val)713 vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT_self(const VkPipelineViewportDepthClipControlCreateInfoEXT *val)
714 {
715 size_t size = 0;
716 /* skip val->{sType,pNext} */
717 size += vn_sizeof_VkBool32(&val->negativeOneToOne);
718 return size;
719 }
720
721 static inline size_t
vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT * val)722 vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT *val)
723 {
724 size_t size = 0;
725
726 size += vn_sizeof_VkStructureType(&val->sType);
727 size += vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext(val->pNext);
728 size += vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT_self(val);
729
730 return size;
731 }
732
733 static inline void
vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)734 vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
735 {
736 /* no known/supported struct */
737 vn_encode_simple_pointer(enc, NULL);
738 }
739
740 static inline void
vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineViewportDepthClipControlCreateInfoEXT * val)741 vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineViewportDepthClipControlCreateInfoEXT *val)
742 {
743 /* skip val->{sType,pNext} */
744 vn_encode_VkBool32(enc, &val->negativeOneToOne);
745 }
746
747 static inline void
vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineViewportDepthClipControlCreateInfoEXT * val)748 vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineViewportDepthClipControlCreateInfoEXT *val)
749 {
750 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT);
751 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT });
752 vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT_pnext(enc, val->pNext);
753 vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT_self(enc, val);
754 }
755
756 /* struct VkPipelineViewportStateCreateInfo chain */
757
758 static inline size_t
vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(const void * val)759 vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(const void *val)
760 {
761 const VkBaseInStructure *pnext = val;
762 size_t size = 0;
763
764 while (pnext) {
765 switch ((int32_t)pnext->sType) {
766 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
767 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
768 break;
769 size += vn_sizeof_simple_pointer(pnext);
770 size += vn_sizeof_VkStructureType(&pnext->sType);
771 size += vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(pnext->pNext);
772 size += vn_sizeof_VkPipelineViewportDepthClipControlCreateInfoEXT_self((const VkPipelineViewportDepthClipControlCreateInfoEXT *)pnext);
773 return size;
774 default:
775 /* ignore unknown/unsupported struct */
776 break;
777 }
778 pnext = pnext->pNext;
779 }
780
781 return vn_sizeof_simple_pointer(NULL);
782 }
783
784 static inline size_t
vn_sizeof_VkPipelineViewportStateCreateInfo_self(const VkPipelineViewportStateCreateInfo * val)785 vn_sizeof_VkPipelineViewportStateCreateInfo_self(const VkPipelineViewportStateCreateInfo *val)
786 {
787 size_t size = 0;
788 /* skip val->{sType,pNext} */
789 size += vn_sizeof_VkFlags(&val->flags);
790 size += vn_sizeof_uint32_t(&val->viewportCount);
791 if (val->pViewports) {
792 size += vn_sizeof_array_size(val->viewportCount);
793 for (uint32_t i = 0; i < val->viewportCount; i++)
794 size += vn_sizeof_VkViewport(&val->pViewports[i]);
795 } else {
796 size += vn_sizeof_array_size(0);
797 }
798 size += vn_sizeof_uint32_t(&val->scissorCount);
799 if (val->pScissors) {
800 size += vn_sizeof_array_size(val->scissorCount);
801 for (uint32_t i = 0; i < val->scissorCount; i++)
802 size += vn_sizeof_VkRect2D(&val->pScissors[i]);
803 } else {
804 size += vn_sizeof_array_size(0);
805 }
806 return size;
807 }
808
809 static inline size_t
vn_sizeof_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo * val)810 vn_sizeof_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo *val)
811 {
812 size_t size = 0;
813
814 size += vn_sizeof_VkStructureType(&val->sType);
815 size += vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(val->pNext);
816 size += vn_sizeof_VkPipelineViewportStateCreateInfo_self(val);
817
818 return size;
819 }
820
821 static inline void
vn_encode_VkPipelineViewportStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)822 vn_encode_VkPipelineViewportStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
823 {
824 const VkBaseInStructure *pnext = val;
825
826 while (pnext) {
827 switch ((int32_t)pnext->sType) {
828 case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
829 if (!vn_cs_renderer_protocol_has_extension(356 /* VK_EXT_depth_clip_control */))
830 break;
831 vn_encode_simple_pointer(enc, pnext);
832 vn_encode_VkStructureType(enc, &pnext->sType);
833 vn_encode_VkPipelineViewportStateCreateInfo_pnext(enc, pnext->pNext);
834 vn_encode_VkPipelineViewportDepthClipControlCreateInfoEXT_self(enc, (const VkPipelineViewportDepthClipControlCreateInfoEXT *)pnext);
835 return;
836 default:
837 /* ignore unknown/unsupported struct */
838 break;
839 }
840 pnext = pnext->pNext;
841 }
842
843 vn_encode_simple_pointer(enc, NULL);
844 }
845
846 static inline void
vn_encode_VkPipelineViewportStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineViewportStateCreateInfo * val)847 vn_encode_VkPipelineViewportStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
848 {
849 /* skip val->{sType,pNext} */
850 vn_encode_VkFlags(enc, &val->flags);
851 vn_encode_uint32_t(enc, &val->viewportCount);
852 if (val->pViewports) {
853 vn_encode_array_size(enc, val->viewportCount);
854 for (uint32_t i = 0; i < val->viewportCount; i++)
855 vn_encode_VkViewport(enc, &val->pViewports[i]);
856 } else {
857 vn_encode_array_size(enc, 0);
858 }
859 vn_encode_uint32_t(enc, &val->scissorCount);
860 if (val->pScissors) {
861 vn_encode_array_size(enc, val->scissorCount);
862 for (uint32_t i = 0; i < val->scissorCount; i++)
863 vn_encode_VkRect2D(enc, &val->pScissors[i]);
864 } else {
865 vn_encode_array_size(enc, 0);
866 }
867 }
868
869 static inline void
vn_encode_VkPipelineViewportStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineViewportStateCreateInfo * val)870 vn_encode_VkPipelineViewportStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
871 {
872 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO);
873 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO });
874 vn_encode_VkPipelineViewportStateCreateInfo_pnext(enc, val->pNext);
875 vn_encode_VkPipelineViewportStateCreateInfo_self(enc, val);
876 }
877
878 /* struct VkPipelineRasterizationConservativeStateCreateInfoEXT chain */
879
880 static inline size_t
vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(const void * val)881 vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(const void *val)
882 {
883 /* no known/supported struct */
884 return vn_sizeof_simple_pointer(NULL);
885 }
886
887 static inline size_t
vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)888 vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
889 {
890 size_t size = 0;
891 /* skip val->{sType,pNext} */
892 size += vn_sizeof_VkFlags(&val->flags);
893 size += vn_sizeof_VkConservativeRasterizationModeEXT(&val->conservativeRasterizationMode);
894 size += vn_sizeof_float(&val->extraPrimitiveOverestimationSize);
895 return size;
896 }
897
898 static inline size_t
vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)899 vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
900 {
901 size_t size = 0;
902
903 size += vn_sizeof_VkStructureType(&val->sType);
904 size += vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(val->pNext);
905 size += vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(val);
906
907 return size;
908 }
909
910 static inline void
vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)911 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
912 {
913 /* no known/supported struct */
914 vn_encode_simple_pointer(enc, NULL);
915 }
916
917 static inline void
vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)918 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
919 {
920 /* skip val->{sType,pNext} */
921 vn_encode_VkFlags(enc, &val->flags);
922 vn_encode_VkConservativeRasterizationModeEXT(enc, &val->conservativeRasterizationMode);
923 vn_encode_float(enc, &val->extraPrimitiveOverestimationSize);
924 }
925
926 static inline void
vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)927 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
928 {
929 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT);
930 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT });
931 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(enc, val->pNext);
932 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(enc, val);
933 }
934
935 /* struct VkPipelineRasterizationStateStreamCreateInfoEXT chain */
936
937 static inline size_t
vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(const void * val)938 vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(const void *val)
939 {
940 /* no known/supported struct */
941 return vn_sizeof_simple_pointer(NULL);
942 }
943
944 static inline size_t
vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(const VkPipelineRasterizationStateStreamCreateInfoEXT * val)945 vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
946 {
947 size_t size = 0;
948 /* skip val->{sType,pNext} */
949 size += vn_sizeof_VkFlags(&val->flags);
950 size += vn_sizeof_uint32_t(&val->rasterizationStream);
951 return size;
952 }
953
954 static inline size_t
vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT * val)955 vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
956 {
957 size_t size = 0;
958
959 size += vn_sizeof_VkStructureType(&val->sType);
960 size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(val->pNext);
961 size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(val);
962
963 return size;
964 }
965
966 static inline void
vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)967 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
968 {
969 /* no known/supported struct */
970 vn_encode_simple_pointer(enc, NULL);
971 }
972
973 static inline void
vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateStreamCreateInfoEXT * val)974 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
975 {
976 /* skip val->{sType,pNext} */
977 vn_encode_VkFlags(enc, &val->flags);
978 vn_encode_uint32_t(enc, &val->rasterizationStream);
979 }
980
981 static inline void
vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateStreamCreateInfoEXT * val)982 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
983 {
984 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT);
985 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT });
986 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(enc, val->pNext);
987 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, val);
988 }
989
990 /* struct VkPipelineRasterizationDepthClipStateCreateInfoEXT chain */
991
992 static inline size_t
vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(const void * val)993 vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(const void *val)
994 {
995 /* no known/supported struct */
996 return vn_sizeof_simple_pointer(NULL);
997 }
998
999 static inline size_t
vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)1000 vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
1001 {
1002 size_t size = 0;
1003 /* skip val->{sType,pNext} */
1004 size += vn_sizeof_VkFlags(&val->flags);
1005 size += vn_sizeof_VkBool32(&val->depthClipEnable);
1006 return size;
1007 }
1008
1009 static inline size_t
vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)1010 vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
1011 {
1012 size_t size = 0;
1013
1014 size += vn_sizeof_VkStructureType(&val->sType);
1015 size += vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(val->pNext);
1016 size += vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(val);
1017
1018 return size;
1019 }
1020
1021 static inline void
vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)1022 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
1023 {
1024 /* no known/supported struct */
1025 vn_encode_simple_pointer(enc, NULL);
1026 }
1027
1028 static inline void
vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)1029 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
1030 {
1031 /* skip val->{sType,pNext} */
1032 vn_encode_VkFlags(enc, &val->flags);
1033 vn_encode_VkBool32(enc, &val->depthClipEnable);
1034 }
1035
1036 static inline void
vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)1037 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
1038 {
1039 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT);
1040 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT });
1041 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(enc, val->pNext);
1042 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(enc, val);
1043 }
1044
1045 /* struct VkPipelineRasterizationLineStateCreateInfoEXT chain */
1046
1047 static inline size_t
vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(const void * val)1048 vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(const void *val)
1049 {
1050 /* no known/supported struct */
1051 return vn_sizeof_simple_pointer(NULL);
1052 }
1053
1054 static inline size_t
vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self(const VkPipelineRasterizationLineStateCreateInfoEXT * val)1055 vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self(const VkPipelineRasterizationLineStateCreateInfoEXT *val)
1056 {
1057 size_t size = 0;
1058 /* skip val->{sType,pNext} */
1059 size += vn_sizeof_VkLineRasterizationModeEXT(&val->lineRasterizationMode);
1060 size += vn_sizeof_VkBool32(&val->stippledLineEnable);
1061 size += vn_sizeof_uint32_t(&val->lineStippleFactor);
1062 size += vn_sizeof_uint16_t(&val->lineStipplePattern);
1063 return size;
1064 }
1065
1066 static inline size_t
vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT * val)1067 vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT *val)
1068 {
1069 size_t size = 0;
1070
1071 size += vn_sizeof_VkStructureType(&val->sType);
1072 size += vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(val->pNext);
1073 size += vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self(val);
1074
1075 return size;
1076 }
1077
1078 static inline void
vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)1079 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
1080 {
1081 /* no known/supported struct */
1082 vn_encode_simple_pointer(enc, NULL);
1083 }
1084
1085 static inline void
vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationLineStateCreateInfoEXT * val)1086 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationLineStateCreateInfoEXT *val)
1087 {
1088 /* skip val->{sType,pNext} */
1089 vn_encode_VkLineRasterizationModeEXT(enc, &val->lineRasterizationMode);
1090 vn_encode_VkBool32(enc, &val->stippledLineEnable);
1091 vn_encode_uint32_t(enc, &val->lineStippleFactor);
1092 vn_encode_uint16_t(enc, &val->lineStipplePattern);
1093 }
1094
1095 static inline void
vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationLineStateCreateInfoEXT * val)1096 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationLineStateCreateInfoEXT *val)
1097 {
1098 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT);
1099 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT });
1100 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(enc, val->pNext);
1101 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(enc, val);
1102 }
1103
1104 /* struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT chain */
1105
1106 static inline size_t
vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(const void * val)1107 vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(const void *val)
1108 {
1109 /* no known/supported struct */
1110 return vn_sizeof_simple_pointer(NULL);
1111 }
1112
1113 static inline size_t
vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1114 vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1115 {
1116 size_t size = 0;
1117 /* skip val->{sType,pNext} */
1118 size += vn_sizeof_VkProvokingVertexModeEXT(&val->provokingVertexMode);
1119 return size;
1120 }
1121
1122 static inline size_t
vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1123 vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1124 {
1125 size_t size = 0;
1126
1127 size += vn_sizeof_VkStructureType(&val->sType);
1128 size += vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(val->pNext);
1129 size += vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(val);
1130
1131 return size;
1132 }
1133
1134 static inline void
vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)1135 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
1136 {
1137 /* no known/supported struct */
1138 vn_encode_simple_pointer(enc, NULL);
1139 }
1140
1141 static inline void
vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1142 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1143 {
1144 /* skip val->{sType,pNext} */
1145 vn_encode_VkProvokingVertexModeEXT(enc, &val->provokingVertexMode);
1146 }
1147
1148 static inline void
vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1149 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1150 {
1151 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT);
1152 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT });
1153 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(enc, val->pNext);
1154 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(enc, val);
1155 }
1156
1157 /* struct VkPipelineRasterizationStateCreateInfo chain */
1158
1159 static inline size_t
vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(const void * val)1160 vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(const void *val)
1161 {
1162 const VkBaseInStructure *pnext = val;
1163 size_t size = 0;
1164
1165 while (pnext) {
1166 switch ((int32_t)pnext->sType) {
1167 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
1168 if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
1169 break;
1170 size += vn_sizeof_simple_pointer(pnext);
1171 size += vn_sizeof_VkStructureType(&pnext->sType);
1172 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1173 size += vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self((const VkPipelineRasterizationConservativeStateCreateInfoEXT *)pnext);
1174 return size;
1175 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
1176 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
1177 break;
1178 size += vn_sizeof_simple_pointer(pnext);
1179 size += vn_sizeof_VkStructureType(&pnext->sType);
1180 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1181 size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self((const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
1182 return size;
1183 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
1184 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
1185 break;
1186 size += vn_sizeof_simple_pointer(pnext);
1187 size += vn_sizeof_VkStructureType(&pnext->sType);
1188 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1189 size += vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self((const VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pnext);
1190 return size;
1191 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
1192 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
1193 break;
1194 size += vn_sizeof_simple_pointer(pnext);
1195 size += vn_sizeof_VkStructureType(&pnext->sType);
1196 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1197 size += vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self((const VkPipelineRasterizationLineStateCreateInfoEXT *)pnext);
1198 return size;
1199 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
1200 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
1201 break;
1202 size += vn_sizeof_simple_pointer(pnext);
1203 size += vn_sizeof_VkStructureType(&pnext->sType);
1204 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1205 size += vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self((const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)pnext);
1206 return size;
1207 default:
1208 /* ignore unknown/unsupported struct */
1209 break;
1210 }
1211 pnext = pnext->pNext;
1212 }
1213
1214 return vn_sizeof_simple_pointer(NULL);
1215 }
1216
1217 static inline size_t
vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(const VkPipelineRasterizationStateCreateInfo * val)1218 vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(const VkPipelineRasterizationStateCreateInfo *val)
1219 {
1220 size_t size = 0;
1221 /* skip val->{sType,pNext} */
1222 size += vn_sizeof_VkFlags(&val->flags);
1223 size += vn_sizeof_VkBool32(&val->depthClampEnable);
1224 size += vn_sizeof_VkBool32(&val->rasterizerDiscardEnable);
1225 size += vn_sizeof_VkPolygonMode(&val->polygonMode);
1226 size += vn_sizeof_VkFlags(&val->cullMode);
1227 size += vn_sizeof_VkFrontFace(&val->frontFace);
1228 size += vn_sizeof_VkBool32(&val->depthBiasEnable);
1229 size += vn_sizeof_float(&val->depthBiasConstantFactor);
1230 size += vn_sizeof_float(&val->depthBiasClamp);
1231 size += vn_sizeof_float(&val->depthBiasSlopeFactor);
1232 size += vn_sizeof_float(&val->lineWidth);
1233 return size;
1234 }
1235
1236 static inline size_t
vn_sizeof_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo * val)1237 vn_sizeof_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo *val)
1238 {
1239 size_t size = 0;
1240
1241 size += vn_sizeof_VkStructureType(&val->sType);
1242 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(val->pNext);
1243 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(val);
1244
1245 return size;
1246 }
1247
1248 static inline void
vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1249 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1250 {
1251 const VkBaseInStructure *pnext = val;
1252
1253 while (pnext) {
1254 switch ((int32_t)pnext->sType) {
1255 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
1256 if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
1257 break;
1258 vn_encode_simple_pointer(enc, pnext);
1259 vn_encode_VkStructureType(enc, &pnext->sType);
1260 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1261 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationConservativeStateCreateInfoEXT *)pnext);
1262 return;
1263 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
1264 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
1265 break;
1266 vn_encode_simple_pointer(enc, pnext);
1267 vn_encode_VkStructureType(enc, &pnext->sType);
1268 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1269 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, (const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
1270 return;
1271 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
1272 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
1273 break;
1274 vn_encode_simple_pointer(enc, pnext);
1275 vn_encode_VkStructureType(enc, &pnext->sType);
1276 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1277 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pnext);
1278 return;
1279 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
1280 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
1281 break;
1282 vn_encode_simple_pointer(enc, pnext);
1283 vn_encode_VkStructureType(enc, &pnext->sType);
1284 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1285 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationLineStateCreateInfoEXT *)pnext);
1286 return;
1287 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
1288 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
1289 break;
1290 vn_encode_simple_pointer(enc, pnext);
1291 vn_encode_VkStructureType(enc, &pnext->sType);
1292 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1293 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)pnext);
1294 return;
1295 default:
1296 /* ignore unknown/unsupported struct */
1297 break;
1298 }
1299 pnext = pnext->pNext;
1300 }
1301
1302 vn_encode_simple_pointer(enc, NULL);
1303 }
1304
1305 static inline void
vn_encode_VkPipelineRasterizationStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateCreateInfo * val)1306 vn_encode_VkPipelineRasterizationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
1307 {
1308 /* skip val->{sType,pNext} */
1309 vn_encode_VkFlags(enc, &val->flags);
1310 vn_encode_VkBool32(enc, &val->depthClampEnable);
1311 vn_encode_VkBool32(enc, &val->rasterizerDiscardEnable);
1312 vn_encode_VkPolygonMode(enc, &val->polygonMode);
1313 vn_encode_VkFlags(enc, &val->cullMode);
1314 vn_encode_VkFrontFace(enc, &val->frontFace);
1315 vn_encode_VkBool32(enc, &val->depthBiasEnable);
1316 vn_encode_float(enc, &val->depthBiasConstantFactor);
1317 vn_encode_float(enc, &val->depthBiasClamp);
1318 vn_encode_float(enc, &val->depthBiasSlopeFactor);
1319 vn_encode_float(enc, &val->lineWidth);
1320 }
1321
1322 static inline void
vn_encode_VkPipelineRasterizationStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateCreateInfo * val)1323 vn_encode_VkPipelineRasterizationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
1324 {
1325 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO);
1326 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO });
1327 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, val->pNext);
1328 vn_encode_VkPipelineRasterizationStateCreateInfo_self(enc, val);
1329 }
1330
1331 /* struct VkPipelineMultisampleStateCreateInfo chain */
1332
1333 static inline size_t
vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(const void * val)1334 vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(const void *val)
1335 {
1336 /* no known/supported struct */
1337 return vn_sizeof_simple_pointer(NULL);
1338 }
1339
1340 static inline size_t
vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(const VkPipelineMultisampleStateCreateInfo * val)1341 vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(const VkPipelineMultisampleStateCreateInfo *val)
1342 {
1343 size_t size = 0;
1344 /* skip val->{sType,pNext} */
1345 size += vn_sizeof_VkFlags(&val->flags);
1346 size += vn_sizeof_VkSampleCountFlagBits(&val->rasterizationSamples);
1347 size += vn_sizeof_VkBool32(&val->sampleShadingEnable);
1348 size += vn_sizeof_float(&val->minSampleShading);
1349 if (val->pSampleMask) {
1350 size += vn_sizeof_array_size((val->rasterizationSamples + 31) / 32);
1351 size += vn_sizeof_VkSampleMask_array(val->pSampleMask, (val->rasterizationSamples + 31) / 32);
1352 } else {
1353 size += vn_sizeof_array_size(0);
1354 }
1355 size += vn_sizeof_VkBool32(&val->alphaToCoverageEnable);
1356 size += vn_sizeof_VkBool32(&val->alphaToOneEnable);
1357 return size;
1358 }
1359
1360 static inline size_t
vn_sizeof_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo * val)1361 vn_sizeof_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo *val)
1362 {
1363 size_t size = 0;
1364
1365 size += vn_sizeof_VkStructureType(&val->sType);
1366 size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(val->pNext);
1367 size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(val);
1368
1369 return size;
1370 }
1371
1372 static inline void
vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1373 vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1374 {
1375 /* no known/supported struct */
1376 vn_encode_simple_pointer(enc, NULL);
1377 }
1378
1379 static inline void
vn_encode_VkPipelineMultisampleStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineMultisampleStateCreateInfo * val)1380 vn_encode_VkPipelineMultisampleStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
1381 {
1382 /* skip val->{sType,pNext} */
1383 vn_encode_VkFlags(enc, &val->flags);
1384 vn_encode_VkSampleCountFlagBits(enc, &val->rasterizationSamples);
1385 vn_encode_VkBool32(enc, &val->sampleShadingEnable);
1386 vn_encode_float(enc, &val->minSampleShading);
1387 if (val->pSampleMask) {
1388 vn_encode_array_size(enc, (val->rasterizationSamples + 31) / 32);
1389 vn_encode_VkSampleMask_array(enc, val->pSampleMask, (val->rasterizationSamples + 31) / 32);
1390 } else {
1391 vn_encode_array_size(enc, 0);
1392 }
1393 vn_encode_VkBool32(enc, &val->alphaToCoverageEnable);
1394 vn_encode_VkBool32(enc, &val->alphaToOneEnable);
1395 }
1396
1397 static inline void
vn_encode_VkPipelineMultisampleStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineMultisampleStateCreateInfo * val)1398 vn_encode_VkPipelineMultisampleStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
1399 {
1400 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO);
1401 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO });
1402 vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(enc, val->pNext);
1403 vn_encode_VkPipelineMultisampleStateCreateInfo_self(enc, val);
1404 }
1405
1406 /* struct VkStencilOpState */
1407
1408 static inline size_t
vn_sizeof_VkStencilOpState(const VkStencilOpState * val)1409 vn_sizeof_VkStencilOpState(const VkStencilOpState *val)
1410 {
1411 size_t size = 0;
1412 size += vn_sizeof_VkStencilOp(&val->failOp);
1413 size += vn_sizeof_VkStencilOp(&val->passOp);
1414 size += vn_sizeof_VkStencilOp(&val->depthFailOp);
1415 size += vn_sizeof_VkCompareOp(&val->compareOp);
1416 size += vn_sizeof_uint32_t(&val->compareMask);
1417 size += vn_sizeof_uint32_t(&val->writeMask);
1418 size += vn_sizeof_uint32_t(&val->reference);
1419 return size;
1420 }
1421
1422 static inline void
vn_encode_VkStencilOpState(struct vn_cs_encoder * enc,const VkStencilOpState * val)1423 vn_encode_VkStencilOpState(struct vn_cs_encoder *enc, const VkStencilOpState *val)
1424 {
1425 vn_encode_VkStencilOp(enc, &val->failOp);
1426 vn_encode_VkStencilOp(enc, &val->passOp);
1427 vn_encode_VkStencilOp(enc, &val->depthFailOp);
1428 vn_encode_VkCompareOp(enc, &val->compareOp);
1429 vn_encode_uint32_t(enc, &val->compareMask);
1430 vn_encode_uint32_t(enc, &val->writeMask);
1431 vn_encode_uint32_t(enc, &val->reference);
1432 }
1433
1434 /* struct VkPipelineDepthStencilStateCreateInfo chain */
1435
1436 static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(const void * val)1437 vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(const void *val)
1438 {
1439 /* no known/supported struct */
1440 return vn_sizeof_simple_pointer(NULL);
1441 }
1442
1443 static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(const VkPipelineDepthStencilStateCreateInfo * val)1444 vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(const VkPipelineDepthStencilStateCreateInfo *val)
1445 {
1446 size_t size = 0;
1447 /* skip val->{sType,pNext} */
1448 size += vn_sizeof_VkFlags(&val->flags);
1449 size += vn_sizeof_VkBool32(&val->depthTestEnable);
1450 size += vn_sizeof_VkBool32(&val->depthWriteEnable);
1451 size += vn_sizeof_VkCompareOp(&val->depthCompareOp);
1452 size += vn_sizeof_VkBool32(&val->depthBoundsTestEnable);
1453 size += vn_sizeof_VkBool32(&val->stencilTestEnable);
1454 size += vn_sizeof_VkStencilOpState(&val->front);
1455 size += vn_sizeof_VkStencilOpState(&val->back);
1456 size += vn_sizeof_float(&val->minDepthBounds);
1457 size += vn_sizeof_float(&val->maxDepthBounds);
1458 return size;
1459 }
1460
1461 static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo * val)1462 vn_sizeof_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo *val)
1463 {
1464 size_t size = 0;
1465
1466 size += vn_sizeof_VkStructureType(&val->sType);
1467 size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(val->pNext);
1468 size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(val);
1469
1470 return size;
1471 }
1472
1473 static inline void
vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1474 vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1475 {
1476 /* no known/supported struct */
1477 vn_encode_simple_pointer(enc, NULL);
1478 }
1479
1480 static inline void
vn_encode_VkPipelineDepthStencilStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineDepthStencilStateCreateInfo * val)1481 vn_encode_VkPipelineDepthStencilStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
1482 {
1483 /* skip val->{sType,pNext} */
1484 vn_encode_VkFlags(enc, &val->flags);
1485 vn_encode_VkBool32(enc, &val->depthTestEnable);
1486 vn_encode_VkBool32(enc, &val->depthWriteEnable);
1487 vn_encode_VkCompareOp(enc, &val->depthCompareOp);
1488 vn_encode_VkBool32(enc, &val->depthBoundsTestEnable);
1489 vn_encode_VkBool32(enc, &val->stencilTestEnable);
1490 vn_encode_VkStencilOpState(enc, &val->front);
1491 vn_encode_VkStencilOpState(enc, &val->back);
1492 vn_encode_float(enc, &val->minDepthBounds);
1493 vn_encode_float(enc, &val->maxDepthBounds);
1494 }
1495
1496 static inline void
vn_encode_VkPipelineDepthStencilStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineDepthStencilStateCreateInfo * val)1497 vn_encode_VkPipelineDepthStencilStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
1498 {
1499 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO);
1500 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO });
1501 vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(enc, val->pNext);
1502 vn_encode_VkPipelineDepthStencilStateCreateInfo_self(enc, val);
1503 }
1504
1505 /* struct VkPipelineColorBlendAttachmentState */
1506
1507 static inline size_t
vn_sizeof_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState * val)1508 vn_sizeof_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState *val)
1509 {
1510 size_t size = 0;
1511 size += vn_sizeof_VkBool32(&val->blendEnable);
1512 size += vn_sizeof_VkBlendFactor(&val->srcColorBlendFactor);
1513 size += vn_sizeof_VkBlendFactor(&val->dstColorBlendFactor);
1514 size += vn_sizeof_VkBlendOp(&val->colorBlendOp);
1515 size += vn_sizeof_VkBlendFactor(&val->srcAlphaBlendFactor);
1516 size += vn_sizeof_VkBlendFactor(&val->dstAlphaBlendFactor);
1517 size += vn_sizeof_VkBlendOp(&val->alphaBlendOp);
1518 size += vn_sizeof_VkFlags(&val->colorWriteMask);
1519 return size;
1520 }
1521
1522 static inline void
vn_encode_VkPipelineColorBlendAttachmentState(struct vn_cs_encoder * enc,const VkPipelineColorBlendAttachmentState * val)1523 vn_encode_VkPipelineColorBlendAttachmentState(struct vn_cs_encoder *enc, const VkPipelineColorBlendAttachmentState *val)
1524 {
1525 vn_encode_VkBool32(enc, &val->blendEnable);
1526 vn_encode_VkBlendFactor(enc, &val->srcColorBlendFactor);
1527 vn_encode_VkBlendFactor(enc, &val->dstColorBlendFactor);
1528 vn_encode_VkBlendOp(enc, &val->colorBlendOp);
1529 vn_encode_VkBlendFactor(enc, &val->srcAlphaBlendFactor);
1530 vn_encode_VkBlendFactor(enc, &val->dstAlphaBlendFactor);
1531 vn_encode_VkBlendOp(enc, &val->alphaBlendOp);
1532 vn_encode_VkFlags(enc, &val->colorWriteMask);
1533 }
1534
1535 /* struct VkPipelineColorWriteCreateInfoEXT chain */
1536
1537 static inline size_t
vn_sizeof_VkPipelineColorWriteCreateInfoEXT_pnext(const void * val)1538 vn_sizeof_VkPipelineColorWriteCreateInfoEXT_pnext(const void *val)
1539 {
1540 /* no known/supported struct */
1541 return vn_sizeof_simple_pointer(NULL);
1542 }
1543
1544 static inline size_t
vn_sizeof_VkPipelineColorWriteCreateInfoEXT_self(const VkPipelineColorWriteCreateInfoEXT * val)1545 vn_sizeof_VkPipelineColorWriteCreateInfoEXT_self(const VkPipelineColorWriteCreateInfoEXT *val)
1546 {
1547 size_t size = 0;
1548 /* skip val->{sType,pNext} */
1549 size += vn_sizeof_uint32_t(&val->attachmentCount);
1550 if (val->pColorWriteEnables) {
1551 size += vn_sizeof_array_size(val->attachmentCount);
1552 size += vn_sizeof_VkBool32_array(val->pColorWriteEnables, val->attachmentCount);
1553 } else {
1554 size += vn_sizeof_array_size(0);
1555 }
1556 return size;
1557 }
1558
1559 static inline size_t
vn_sizeof_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT * val)1560 vn_sizeof_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT *val)
1561 {
1562 size_t size = 0;
1563
1564 size += vn_sizeof_VkStructureType(&val->sType);
1565 size += vn_sizeof_VkPipelineColorWriteCreateInfoEXT_pnext(val->pNext);
1566 size += vn_sizeof_VkPipelineColorWriteCreateInfoEXT_self(val);
1567
1568 return size;
1569 }
1570
1571 static inline void
vn_encode_VkPipelineColorWriteCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)1572 vn_encode_VkPipelineColorWriteCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
1573 {
1574 /* no known/supported struct */
1575 vn_encode_simple_pointer(enc, NULL);
1576 }
1577
1578 static inline void
vn_encode_VkPipelineColorWriteCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineColorWriteCreateInfoEXT * val)1579 vn_encode_VkPipelineColorWriteCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineColorWriteCreateInfoEXT *val)
1580 {
1581 /* skip val->{sType,pNext} */
1582 vn_encode_uint32_t(enc, &val->attachmentCount);
1583 if (val->pColorWriteEnables) {
1584 vn_encode_array_size(enc, val->attachmentCount);
1585 vn_encode_VkBool32_array(enc, val->pColorWriteEnables, val->attachmentCount);
1586 } else {
1587 vn_encode_array_size(enc, 0);
1588 }
1589 }
1590
1591 static inline void
vn_encode_VkPipelineColorWriteCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineColorWriteCreateInfoEXT * val)1592 vn_encode_VkPipelineColorWriteCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineColorWriteCreateInfoEXT *val)
1593 {
1594 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT);
1595 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT });
1596 vn_encode_VkPipelineColorWriteCreateInfoEXT_pnext(enc, val->pNext);
1597 vn_encode_VkPipelineColorWriteCreateInfoEXT_self(enc, val);
1598 }
1599
1600 /* struct VkPipelineColorBlendStateCreateInfo chain */
1601
1602 static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(const void * val)1603 vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(const void *val)
1604 {
1605 const VkBaseInStructure *pnext = val;
1606 size_t size = 0;
1607
1608 while (pnext) {
1609 switch ((int32_t)pnext->sType) {
1610 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
1611 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
1612 break;
1613 size += vn_sizeof_simple_pointer(pnext);
1614 size += vn_sizeof_VkStructureType(&pnext->sType);
1615 size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(pnext->pNext);
1616 size += vn_sizeof_VkPipelineColorWriteCreateInfoEXT_self((const VkPipelineColorWriteCreateInfoEXT *)pnext);
1617 return size;
1618 default:
1619 /* ignore unknown/unsupported struct */
1620 break;
1621 }
1622 pnext = pnext->pNext;
1623 }
1624
1625 return vn_sizeof_simple_pointer(NULL);
1626 }
1627
1628 static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(const VkPipelineColorBlendStateCreateInfo * val)1629 vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(const VkPipelineColorBlendStateCreateInfo *val)
1630 {
1631 size_t size = 0;
1632 /* skip val->{sType,pNext} */
1633 size += vn_sizeof_VkFlags(&val->flags);
1634 size += vn_sizeof_VkBool32(&val->logicOpEnable);
1635 size += vn_sizeof_VkLogicOp(&val->logicOp);
1636 size += vn_sizeof_uint32_t(&val->attachmentCount);
1637 if (val->pAttachments) {
1638 size += vn_sizeof_array_size(val->attachmentCount);
1639 for (uint32_t i = 0; i < val->attachmentCount; i++)
1640 size += vn_sizeof_VkPipelineColorBlendAttachmentState(&val->pAttachments[i]);
1641 } else {
1642 size += vn_sizeof_array_size(0);
1643 }
1644 size += vn_sizeof_array_size(4);
1645 size += vn_sizeof_float_array(val->blendConstants, 4);
1646 return size;
1647 }
1648
1649 static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo * val)1650 vn_sizeof_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo *val)
1651 {
1652 size_t size = 0;
1653
1654 size += vn_sizeof_VkStructureType(&val->sType);
1655 size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(val->pNext);
1656 size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(val);
1657
1658 return size;
1659 }
1660
1661 static inline void
vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1662 vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1663 {
1664 const VkBaseInStructure *pnext = val;
1665
1666 while (pnext) {
1667 switch ((int32_t)pnext->sType) {
1668 case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
1669 if (!vn_cs_renderer_protocol_has_extension(382 /* VK_EXT_color_write_enable */))
1670 break;
1671 vn_encode_simple_pointer(enc, pnext);
1672 vn_encode_VkStructureType(enc, &pnext->sType);
1673 vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(enc, pnext->pNext);
1674 vn_encode_VkPipelineColorWriteCreateInfoEXT_self(enc, (const VkPipelineColorWriteCreateInfoEXT *)pnext);
1675 return;
1676 default:
1677 /* ignore unknown/unsupported struct */
1678 break;
1679 }
1680 pnext = pnext->pNext;
1681 }
1682
1683 vn_encode_simple_pointer(enc, NULL);
1684 }
1685
1686 static inline void
vn_encode_VkPipelineColorBlendStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineColorBlendStateCreateInfo * val)1687 vn_encode_VkPipelineColorBlendStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
1688 {
1689 /* skip val->{sType,pNext} */
1690 vn_encode_VkFlags(enc, &val->flags);
1691 vn_encode_VkBool32(enc, &val->logicOpEnable);
1692 vn_encode_VkLogicOp(enc, &val->logicOp);
1693 vn_encode_uint32_t(enc, &val->attachmentCount);
1694 if (val->pAttachments) {
1695 vn_encode_array_size(enc, val->attachmentCount);
1696 for (uint32_t i = 0; i < val->attachmentCount; i++)
1697 vn_encode_VkPipelineColorBlendAttachmentState(enc, &val->pAttachments[i]);
1698 } else {
1699 vn_encode_array_size(enc, 0);
1700 }
1701 vn_encode_array_size(enc, 4);
1702 vn_encode_float_array(enc, val->blendConstants, 4);
1703 }
1704
1705 static inline void
vn_encode_VkPipelineColorBlendStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineColorBlendStateCreateInfo * val)1706 vn_encode_VkPipelineColorBlendStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
1707 {
1708 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO);
1709 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO });
1710 vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(enc, val->pNext);
1711 vn_encode_VkPipelineColorBlendStateCreateInfo_self(enc, val);
1712 }
1713
1714 /* struct VkPipelineDynamicStateCreateInfo chain */
1715
1716 static inline size_t
vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(const void * val)1717 vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(const void *val)
1718 {
1719 /* no known/supported struct */
1720 return vn_sizeof_simple_pointer(NULL);
1721 }
1722
1723 static inline size_t
vn_sizeof_VkPipelineDynamicStateCreateInfo_self(const VkPipelineDynamicStateCreateInfo * val)1724 vn_sizeof_VkPipelineDynamicStateCreateInfo_self(const VkPipelineDynamicStateCreateInfo *val)
1725 {
1726 size_t size = 0;
1727 /* skip val->{sType,pNext} */
1728 size += vn_sizeof_VkFlags(&val->flags);
1729 size += vn_sizeof_uint32_t(&val->dynamicStateCount);
1730 if (val->pDynamicStates) {
1731 size += vn_sizeof_array_size(val->dynamicStateCount);
1732 size += vn_sizeof_VkDynamicState_array(val->pDynamicStates, val->dynamicStateCount);
1733 } else {
1734 size += vn_sizeof_array_size(0);
1735 }
1736 return size;
1737 }
1738
1739 static inline size_t
vn_sizeof_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo * val)1740 vn_sizeof_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo *val)
1741 {
1742 size_t size = 0;
1743
1744 size += vn_sizeof_VkStructureType(&val->sType);
1745 size += vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(val->pNext);
1746 size += vn_sizeof_VkPipelineDynamicStateCreateInfo_self(val);
1747
1748 return size;
1749 }
1750
1751 static inline void
vn_encode_VkPipelineDynamicStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1752 vn_encode_VkPipelineDynamicStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1753 {
1754 /* no known/supported struct */
1755 vn_encode_simple_pointer(enc, NULL);
1756 }
1757
1758 static inline void
vn_encode_VkPipelineDynamicStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineDynamicStateCreateInfo * val)1759 vn_encode_VkPipelineDynamicStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
1760 {
1761 /* skip val->{sType,pNext} */
1762 vn_encode_VkFlags(enc, &val->flags);
1763 vn_encode_uint32_t(enc, &val->dynamicStateCount);
1764 if (val->pDynamicStates) {
1765 vn_encode_array_size(enc, val->dynamicStateCount);
1766 vn_encode_VkDynamicState_array(enc, val->pDynamicStates, val->dynamicStateCount);
1767 } else {
1768 vn_encode_array_size(enc, 0);
1769 }
1770 }
1771
1772 static inline void
vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineDynamicStateCreateInfo * val)1773 vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
1774 {
1775 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO);
1776 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO });
1777 vn_encode_VkPipelineDynamicStateCreateInfo_pnext(enc, val->pNext);
1778 vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val);
1779 }
1780
1781 /* struct VkPipelineCreateFlags2CreateInfoKHR chain */
1782
1783 static inline size_t
vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_pnext(const void * val)1784 vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_pnext(const void *val)
1785 {
1786 /* no known/supported struct */
1787 return vn_sizeof_simple_pointer(NULL);
1788 }
1789
1790 static inline size_t
vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self(const VkPipelineCreateFlags2CreateInfoKHR * val)1791 vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self(const VkPipelineCreateFlags2CreateInfoKHR *val)
1792 {
1793 size_t size = 0;
1794 /* skip val->{sType,pNext} */
1795 size += vn_sizeof_VkFlags64(&val->flags);
1796 return size;
1797 }
1798
1799 static inline size_t
vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR * val)1800 vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR *val)
1801 {
1802 size_t size = 0;
1803
1804 size += vn_sizeof_VkStructureType(&val->sType);
1805 size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_pnext(val->pNext);
1806 size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self(val);
1807
1808 return size;
1809 }
1810
1811 static inline void
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_pnext(struct vn_cs_encoder * enc,const void * val)1812 vn_encode_VkPipelineCreateFlags2CreateInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
1813 {
1814 /* no known/supported struct */
1815 vn_encode_simple_pointer(enc, NULL);
1816 }
1817
1818 static inline void
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(struct vn_cs_encoder * enc,const VkPipelineCreateFlags2CreateInfoKHR * val)1819 vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(struct vn_cs_encoder *enc, const VkPipelineCreateFlags2CreateInfoKHR *val)
1820 {
1821 /* skip val->{sType,pNext} */
1822 vn_encode_VkFlags64(enc, &val->flags);
1823 }
1824
1825 static inline void
vn_encode_VkPipelineCreateFlags2CreateInfoKHR(struct vn_cs_encoder * enc,const VkPipelineCreateFlags2CreateInfoKHR * val)1826 vn_encode_VkPipelineCreateFlags2CreateInfoKHR(struct vn_cs_encoder *enc, const VkPipelineCreateFlags2CreateInfoKHR *val)
1827 {
1828 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR);
1829 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR });
1830 vn_encode_VkPipelineCreateFlags2CreateInfoKHR_pnext(enc, val->pNext);
1831 vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(enc, val);
1832 }
1833
1834 /* struct VkPipelineLibraryCreateInfoKHR chain */
1835
1836 static inline size_t
vn_sizeof_VkPipelineLibraryCreateInfoKHR_pnext(const void * val)1837 vn_sizeof_VkPipelineLibraryCreateInfoKHR_pnext(const void *val)
1838 {
1839 /* no known/supported struct */
1840 return vn_sizeof_simple_pointer(NULL);
1841 }
1842
1843 static inline size_t
vn_sizeof_VkPipelineLibraryCreateInfoKHR_self(const VkPipelineLibraryCreateInfoKHR * val)1844 vn_sizeof_VkPipelineLibraryCreateInfoKHR_self(const VkPipelineLibraryCreateInfoKHR *val)
1845 {
1846 size_t size = 0;
1847 /* skip val->{sType,pNext} */
1848 size += vn_sizeof_uint32_t(&val->libraryCount);
1849 if (val->pLibraries) {
1850 size += vn_sizeof_array_size(val->libraryCount);
1851 for (uint32_t i = 0; i < val->libraryCount; i++)
1852 size += vn_sizeof_VkPipeline(&val->pLibraries[i]);
1853 } else {
1854 size += vn_sizeof_array_size(0);
1855 }
1856 return size;
1857 }
1858
1859 static inline size_t
vn_sizeof_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR * val)1860 vn_sizeof_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR *val)
1861 {
1862 size_t size = 0;
1863
1864 size += vn_sizeof_VkStructureType(&val->sType);
1865 size += vn_sizeof_VkPipelineLibraryCreateInfoKHR_pnext(val->pNext);
1866 size += vn_sizeof_VkPipelineLibraryCreateInfoKHR_self(val);
1867
1868 return size;
1869 }
1870
1871 static inline void
vn_encode_VkPipelineLibraryCreateInfoKHR_pnext(struct vn_cs_encoder * enc,const void * val)1872 vn_encode_VkPipelineLibraryCreateInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
1873 {
1874 /* no known/supported struct */
1875 vn_encode_simple_pointer(enc, NULL);
1876 }
1877
1878 static inline void
vn_encode_VkPipelineLibraryCreateInfoKHR_self(struct vn_cs_encoder * enc,const VkPipelineLibraryCreateInfoKHR * val)1879 vn_encode_VkPipelineLibraryCreateInfoKHR_self(struct vn_cs_encoder *enc, const VkPipelineLibraryCreateInfoKHR *val)
1880 {
1881 /* skip val->{sType,pNext} */
1882 vn_encode_uint32_t(enc, &val->libraryCount);
1883 if (val->pLibraries) {
1884 vn_encode_array_size(enc, val->libraryCount);
1885 for (uint32_t i = 0; i < val->libraryCount; i++)
1886 vn_encode_VkPipeline(enc, &val->pLibraries[i]);
1887 } else {
1888 vn_encode_array_size(enc, 0);
1889 }
1890 }
1891
1892 static inline void
vn_encode_VkPipelineLibraryCreateInfoKHR(struct vn_cs_encoder * enc,const VkPipelineLibraryCreateInfoKHR * val)1893 vn_encode_VkPipelineLibraryCreateInfoKHR(struct vn_cs_encoder *enc, const VkPipelineLibraryCreateInfoKHR *val)
1894 {
1895 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR);
1896 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR });
1897 vn_encode_VkPipelineLibraryCreateInfoKHR_pnext(enc, val->pNext);
1898 vn_encode_VkPipelineLibraryCreateInfoKHR_self(enc, val);
1899 }
1900
1901 /* struct VkPipelineCreationFeedback */
1902
1903 static inline size_t
vn_sizeof_VkPipelineCreationFeedback(const VkPipelineCreationFeedback * val)1904 vn_sizeof_VkPipelineCreationFeedback(const VkPipelineCreationFeedback *val)
1905 {
1906 size_t size = 0;
1907 size += vn_sizeof_VkFlags(&val->flags);
1908 size += vn_sizeof_uint64_t(&val->duration);
1909 return size;
1910 }
1911
1912 static inline void
vn_encode_VkPipelineCreationFeedback(struct vn_cs_encoder * enc,const VkPipelineCreationFeedback * val)1913 vn_encode_VkPipelineCreationFeedback(struct vn_cs_encoder *enc, const VkPipelineCreationFeedback *val)
1914 {
1915 vn_encode_VkFlags(enc, &val->flags);
1916 vn_encode_uint64_t(enc, &val->duration);
1917 }
1918
1919 /* struct VkPipelineCreationFeedbackCreateInfo chain */
1920
1921 static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(const void * val)1922 vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(const void *val)
1923 {
1924 /* no known/supported struct */
1925 return vn_sizeof_simple_pointer(NULL);
1926 }
1927
1928 static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(const VkPipelineCreationFeedbackCreateInfo * val)1929 vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(const VkPipelineCreationFeedbackCreateInfo *val)
1930 {
1931 size_t size = 0;
1932 /* skip val->{sType,pNext} */
1933 size += vn_sizeof_simple_pointer(val->pPipelineCreationFeedback);
1934 if (val->pPipelineCreationFeedback)
1935 size += vn_sizeof_VkPipelineCreationFeedback(val->pPipelineCreationFeedback);
1936 size += vn_sizeof_uint32_t(&val->pipelineStageCreationFeedbackCount);
1937 if (val->pPipelineStageCreationFeedbacks) {
1938 size += vn_sizeof_array_size(val->pipelineStageCreationFeedbackCount);
1939 for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
1940 size += vn_sizeof_VkPipelineCreationFeedback(&val->pPipelineStageCreationFeedbacks[i]);
1941 } else {
1942 size += vn_sizeof_array_size(0);
1943 }
1944 return size;
1945 }
1946
1947 static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo * val)1948 vn_sizeof_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo *val)
1949 {
1950 size_t size = 0;
1951
1952 size += vn_sizeof_VkStructureType(&val->sType);
1953 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(val->pNext);
1954 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(val);
1955
1956 return size;
1957 }
1958
1959 static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1960 vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1961 {
1962 /* no known/supported struct */
1963 vn_encode_simple_pointer(enc, NULL);
1964 }
1965
1966 static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineCreationFeedbackCreateInfo * val)1967 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val)
1968 {
1969 /* skip val->{sType,pNext} */
1970 if (vn_encode_simple_pointer(enc, val->pPipelineCreationFeedback))
1971 vn_encode_VkPipelineCreationFeedback(enc, val->pPipelineCreationFeedback);
1972 vn_encode_uint32_t(enc, &val->pipelineStageCreationFeedbackCount);
1973 if (val->pPipelineStageCreationFeedbacks) {
1974 vn_encode_array_size(enc, val->pipelineStageCreationFeedbackCount);
1975 for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
1976 vn_encode_VkPipelineCreationFeedback(enc, &val->pPipelineStageCreationFeedbacks[i]);
1977 } else {
1978 vn_encode_array_size(enc, 0);
1979 }
1980 }
1981
1982 static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo(struct vn_cs_encoder * enc,const VkPipelineCreationFeedbackCreateInfo * val)1983 vn_encode_VkPipelineCreationFeedbackCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val)
1984 {
1985 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
1986 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO });
1987 vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(enc, val->pNext);
1988 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, val);
1989 }
1990
1991 /* struct VkPipelineFragmentShadingRateStateCreateInfoKHR chain */
1992
1993 static inline size_t
vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR_pnext(const void * val)1994 vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR_pnext(const void *val)
1995 {
1996 /* no known/supported struct */
1997 return vn_sizeof_simple_pointer(NULL);
1998 }
1999
2000 static inline size_t
vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR_self(const VkPipelineFragmentShadingRateStateCreateInfoKHR * val)2001 vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR_self(const VkPipelineFragmentShadingRateStateCreateInfoKHR *val)
2002 {
2003 size_t size = 0;
2004 /* skip val->{sType,pNext} */
2005 size += vn_sizeof_VkExtent2D(&val->fragmentSize);
2006 size += vn_sizeof_array_size(2);
2007 size += vn_sizeof_VkFragmentShadingRateCombinerOpKHR_array(val->combinerOps, 2);
2008 return size;
2009 }
2010
2011 static inline size_t
vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR * val)2012 vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR *val)
2013 {
2014 size_t size = 0;
2015
2016 size += vn_sizeof_VkStructureType(&val->sType);
2017 size += vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR_pnext(val->pNext);
2018 size += vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR_self(val);
2019
2020 return size;
2021 }
2022
2023 static inline void
vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR_pnext(struct vn_cs_encoder * enc,const void * val)2024 vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
2025 {
2026 /* no known/supported struct */
2027 vn_encode_simple_pointer(enc, NULL);
2028 }
2029
2030 static inline void
vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR_self(struct vn_cs_encoder * enc,const VkPipelineFragmentShadingRateStateCreateInfoKHR * val)2031 vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR_self(struct vn_cs_encoder *enc, const VkPipelineFragmentShadingRateStateCreateInfoKHR *val)
2032 {
2033 /* skip val->{sType,pNext} */
2034 vn_encode_VkExtent2D(enc, &val->fragmentSize);
2035 vn_encode_array_size(enc, 2);
2036 vn_encode_VkFragmentShadingRateCombinerOpKHR_array(enc, val->combinerOps, 2);
2037 }
2038
2039 static inline void
vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR(struct vn_cs_encoder * enc,const VkPipelineFragmentShadingRateStateCreateInfoKHR * val)2040 vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR(struct vn_cs_encoder *enc, const VkPipelineFragmentShadingRateStateCreateInfoKHR *val)
2041 {
2042 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR);
2043 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR });
2044 vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR_pnext(enc, val->pNext);
2045 vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR_self(enc, val);
2046 }
2047
2048 /* struct VkPipelineRenderingCreateInfo chain */
2049
2050 static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo_pnext(const void * val)2051 vn_sizeof_VkPipelineRenderingCreateInfo_pnext(const void *val)
2052 {
2053 /* no known/supported struct */
2054 return vn_sizeof_simple_pointer(NULL);
2055 }
2056
2057 static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo_self(const VkPipelineRenderingCreateInfo * val)2058 vn_sizeof_VkPipelineRenderingCreateInfo_self(const VkPipelineRenderingCreateInfo *val)
2059 {
2060 size_t size = 0;
2061 /* skip val->{sType,pNext} */
2062 size += vn_sizeof_uint32_t(&val->viewMask);
2063 size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
2064 if (val->pColorAttachmentFormats) {
2065 size += vn_sizeof_array_size(val->colorAttachmentCount);
2066 size += vn_sizeof_VkFormat_array(val->pColorAttachmentFormats, val->colorAttachmentCount);
2067 } else {
2068 size += vn_sizeof_array_size(0);
2069 }
2070 size += vn_sizeof_VkFormat(&val->depthAttachmentFormat);
2071 size += vn_sizeof_VkFormat(&val->stencilAttachmentFormat);
2072 return size;
2073 }
2074
2075 static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo * val)2076 vn_sizeof_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo *val)
2077 {
2078 size_t size = 0;
2079
2080 size += vn_sizeof_VkStructureType(&val->sType);
2081 size += vn_sizeof_VkPipelineRenderingCreateInfo_pnext(val->pNext);
2082 size += vn_sizeof_VkPipelineRenderingCreateInfo_self(val);
2083
2084 return size;
2085 }
2086
2087 static inline void
vn_encode_VkPipelineRenderingCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)2088 vn_encode_VkPipelineRenderingCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
2089 {
2090 /* no known/supported struct */
2091 vn_encode_simple_pointer(enc, NULL);
2092 }
2093
2094 static inline void
vn_encode_VkPipelineRenderingCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineRenderingCreateInfo * val)2095 vn_encode_VkPipelineRenderingCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val)
2096 {
2097 /* skip val->{sType,pNext} */
2098 vn_encode_uint32_t(enc, &val->viewMask);
2099 vn_encode_uint32_t(enc, &val->colorAttachmentCount);
2100 if (val->pColorAttachmentFormats) {
2101 vn_encode_array_size(enc, val->colorAttachmentCount);
2102 vn_encode_VkFormat_array(enc, val->pColorAttachmentFormats, val->colorAttachmentCount);
2103 } else {
2104 vn_encode_array_size(enc, 0);
2105 }
2106 vn_encode_VkFormat(enc, &val->depthAttachmentFormat);
2107 vn_encode_VkFormat(enc, &val->stencilAttachmentFormat);
2108 }
2109
2110 static inline void
vn_encode_VkPipelineRenderingCreateInfo(struct vn_cs_encoder * enc,const VkPipelineRenderingCreateInfo * val)2111 vn_encode_VkPipelineRenderingCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val)
2112 {
2113 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
2114 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO });
2115 vn_encode_VkPipelineRenderingCreateInfo_pnext(enc, val->pNext);
2116 vn_encode_VkPipelineRenderingCreateInfo_self(enc, val);
2117 }
2118
2119 /* struct VkGraphicsPipelineLibraryCreateInfoEXT chain */
2120
2121 static inline size_t
vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT_pnext(const void * val)2122 vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT_pnext(const void *val)
2123 {
2124 /* no known/supported struct */
2125 return vn_sizeof_simple_pointer(NULL);
2126 }
2127
2128 static inline size_t
vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT_self(const VkGraphicsPipelineLibraryCreateInfoEXT * val)2129 vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT_self(const VkGraphicsPipelineLibraryCreateInfoEXT *val)
2130 {
2131 size_t size = 0;
2132 /* skip val->{sType,pNext} */
2133 size += vn_sizeof_VkFlags(&val->flags);
2134 return size;
2135 }
2136
2137 static inline size_t
vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT * val)2138 vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT *val)
2139 {
2140 size_t size = 0;
2141
2142 size += vn_sizeof_VkStructureType(&val->sType);
2143 size += vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT_pnext(val->pNext);
2144 size += vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT_self(val);
2145
2146 return size;
2147 }
2148
2149 static inline void
vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)2150 vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
2151 {
2152 /* no known/supported struct */
2153 vn_encode_simple_pointer(enc, NULL);
2154 }
2155
2156 static inline void
vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkGraphicsPipelineLibraryCreateInfoEXT * val)2157 vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkGraphicsPipelineLibraryCreateInfoEXT *val)
2158 {
2159 /* skip val->{sType,pNext} */
2160 vn_encode_VkFlags(enc, &val->flags);
2161 }
2162
2163 static inline void
vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT(struct vn_cs_encoder * enc,const VkGraphicsPipelineLibraryCreateInfoEXT * val)2164 vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT(struct vn_cs_encoder *enc, const VkGraphicsPipelineLibraryCreateInfoEXT *val)
2165 {
2166 assert(val->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT);
2167 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT });
2168 vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT_pnext(enc, val->pNext);
2169 vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT_self(enc, val);
2170 }
2171
2172 /* struct VkGraphicsPipelineCreateInfo chain */
2173
2174 static inline size_t
vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void * val)2175 vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val)
2176 {
2177 const VkBaseInStructure *pnext = val;
2178 size_t size = 0;
2179
2180 while (pnext) {
2181 switch ((int32_t)pnext->sType) {
2182 case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
2183 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
2184 break;
2185 size += vn_sizeof_simple_pointer(pnext);
2186 size += vn_sizeof_VkStructureType(&pnext->sType);
2187 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
2188 size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self((const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
2189 return size;
2190 case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
2191 if (!vn_cs_renderer_protocol_has_extension(291 /* VK_KHR_pipeline_library */))
2192 break;
2193 size += vn_sizeof_simple_pointer(pnext);
2194 size += vn_sizeof_VkStructureType(&pnext->sType);
2195 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
2196 size += vn_sizeof_VkPipelineLibraryCreateInfoKHR_self((const VkPipelineLibraryCreateInfoKHR *)pnext);
2197 return size;
2198 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
2199 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
2200 break;
2201 size += vn_sizeof_simple_pointer(pnext);
2202 size += vn_sizeof_VkStructureType(&pnext->sType);
2203 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
2204 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext);
2205 return size;
2206 case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
2207 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
2208 break;
2209 size += vn_sizeof_simple_pointer(pnext);
2210 size += vn_sizeof_VkStructureType(&pnext->sType);
2211 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
2212 size += vn_sizeof_VkPipelineFragmentShadingRateStateCreateInfoKHR_self((const VkPipelineFragmentShadingRateStateCreateInfoKHR *)pnext);
2213 return size;
2214 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
2215 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
2216 break;
2217 size += vn_sizeof_simple_pointer(pnext);
2218 size += vn_sizeof_VkStructureType(&pnext->sType);
2219 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
2220 size += vn_sizeof_VkPipelineRenderingCreateInfo_self((const VkPipelineRenderingCreateInfo *)pnext);
2221 return size;
2222 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
2223 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
2224 break;
2225 size += vn_sizeof_simple_pointer(pnext);
2226 size += vn_sizeof_VkStructureType(&pnext->sType);
2227 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
2228 size += vn_sizeof_VkGraphicsPipelineLibraryCreateInfoEXT_self((const VkGraphicsPipelineLibraryCreateInfoEXT *)pnext);
2229 return size;
2230 default:
2231 /* ignore unknown/unsupported struct */
2232 break;
2233 }
2234 pnext = pnext->pNext;
2235 }
2236
2237 return vn_sizeof_simple_pointer(NULL);
2238 }
2239
2240 static inline size_t
vn_sizeof_VkGraphicsPipelineCreateInfo_self(const VkGraphicsPipelineCreateInfo * val)2241 vn_sizeof_VkGraphicsPipelineCreateInfo_self(const VkGraphicsPipelineCreateInfo *val)
2242 {
2243 size_t size = 0;
2244 /* skip val->{sType,pNext} */
2245 size += vn_sizeof_VkFlags(&val->flags);
2246 size += vn_sizeof_uint32_t(&val->stageCount);
2247 if (val->pStages) {
2248 size += vn_sizeof_array_size(val->stageCount);
2249 for (uint32_t i = 0; i < val->stageCount; i++)
2250 size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->pStages[i]);
2251 } else {
2252 size += vn_sizeof_array_size(0);
2253 }
2254 size += vn_sizeof_simple_pointer(val->pVertexInputState);
2255 if (val->pVertexInputState)
2256 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo(val->pVertexInputState);
2257 size += vn_sizeof_simple_pointer(val->pInputAssemblyState);
2258 if (val->pInputAssemblyState)
2259 size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(val->pInputAssemblyState);
2260 size += vn_sizeof_simple_pointer(val->pTessellationState);
2261 if (val->pTessellationState)
2262 size += vn_sizeof_VkPipelineTessellationStateCreateInfo(val->pTessellationState);
2263 size += vn_sizeof_simple_pointer(val->pViewportState);
2264 if (val->pViewportState)
2265 size += vn_sizeof_VkPipelineViewportStateCreateInfo(val->pViewportState);
2266 size += vn_sizeof_simple_pointer(val->pRasterizationState);
2267 if (val->pRasterizationState)
2268 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo(val->pRasterizationState);
2269 size += vn_sizeof_simple_pointer(val->pMultisampleState);
2270 if (val->pMultisampleState)
2271 size += vn_sizeof_VkPipelineMultisampleStateCreateInfo(val->pMultisampleState);
2272 size += vn_sizeof_simple_pointer(val->pDepthStencilState);
2273 if (val->pDepthStencilState)
2274 size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo(val->pDepthStencilState);
2275 size += vn_sizeof_simple_pointer(val->pColorBlendState);
2276 if (val->pColorBlendState)
2277 size += vn_sizeof_VkPipelineColorBlendStateCreateInfo(val->pColorBlendState);
2278 size += vn_sizeof_simple_pointer(val->pDynamicState);
2279 if (val->pDynamicState)
2280 size += vn_sizeof_VkPipelineDynamicStateCreateInfo(val->pDynamicState);
2281 size += vn_sizeof_VkPipelineLayout(&val->layout);
2282 size += vn_sizeof_VkRenderPass(&val->renderPass);
2283 size += vn_sizeof_uint32_t(&val->subpass);
2284 size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
2285 size += vn_sizeof_int32_t(&val->basePipelineIndex);
2286 return size;
2287 }
2288
2289 static inline size_t
vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo * val)2290 vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *val)
2291 {
2292 size_t size = 0;
2293
2294 size += vn_sizeof_VkStructureType(&val->sType);
2295 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(val->pNext);
2296 size += vn_sizeof_VkGraphicsPipelineCreateInfo_self(val);
2297
2298 return size;
2299 }
2300
2301 static inline void
vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)2302 vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
2303 {
2304 const VkBaseInStructure *pnext = val;
2305
2306 while (pnext) {
2307 switch ((int32_t)pnext->sType) {
2308 case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
2309 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
2310 break;
2311 vn_encode_simple_pointer(enc, pnext);
2312 vn_encode_VkStructureType(enc, &pnext->sType);
2313 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
2314 vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(enc, (const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
2315 return;
2316 case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
2317 if (!vn_cs_renderer_protocol_has_extension(291 /* VK_KHR_pipeline_library */))
2318 break;
2319 vn_encode_simple_pointer(enc, pnext);
2320 vn_encode_VkStructureType(enc, &pnext->sType);
2321 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
2322 vn_encode_VkPipelineLibraryCreateInfoKHR_self(enc, (const VkPipelineLibraryCreateInfoKHR *)pnext);
2323 return;
2324 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
2325 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
2326 break;
2327 vn_encode_simple_pointer(enc, pnext);
2328 vn_encode_VkStructureType(enc, &pnext->sType);
2329 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
2330 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext);
2331 return;
2332 case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
2333 if (!vn_cs_renderer_protocol_has_extension(227 /* VK_KHR_fragment_shading_rate */))
2334 break;
2335 vn_encode_simple_pointer(enc, pnext);
2336 vn_encode_VkStructureType(enc, &pnext->sType);
2337 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
2338 vn_encode_VkPipelineFragmentShadingRateStateCreateInfoKHR_self(enc, (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)pnext);
2339 return;
2340 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
2341 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
2342 break;
2343 vn_encode_simple_pointer(enc, pnext);
2344 vn_encode_VkStructureType(enc, &pnext->sType);
2345 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
2346 vn_encode_VkPipelineRenderingCreateInfo_self(enc, (const VkPipelineRenderingCreateInfo *)pnext);
2347 return;
2348 case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
2349 if (!vn_cs_renderer_protocol_has_extension(321 /* VK_EXT_graphics_pipeline_library */))
2350 break;
2351 vn_encode_simple_pointer(enc, pnext);
2352 vn_encode_VkStructureType(enc, &pnext->sType);
2353 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
2354 vn_encode_VkGraphicsPipelineLibraryCreateInfoEXT_self(enc, (const VkGraphicsPipelineLibraryCreateInfoEXT *)pnext);
2355 return;
2356 default:
2357 /* ignore unknown/unsupported struct */
2358 break;
2359 }
2360 pnext = pnext->pNext;
2361 }
2362
2363 vn_encode_simple_pointer(enc, NULL);
2364 }
2365
2366 static inline void
vn_encode_VkGraphicsPipelineCreateInfo_self(struct vn_cs_encoder * enc,const VkGraphicsPipelineCreateInfo * val)2367 vn_encode_VkGraphicsPipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
2368 {
2369 /* skip val->{sType,pNext} */
2370 vn_encode_VkFlags(enc, &val->flags);
2371 vn_encode_uint32_t(enc, &val->stageCount);
2372 if (val->pStages) {
2373 vn_encode_array_size(enc, val->stageCount);
2374 for (uint32_t i = 0; i < val->stageCount; i++)
2375 vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->pStages[i]);
2376 } else {
2377 vn_encode_array_size(enc, 0);
2378 }
2379 if (vn_encode_simple_pointer(enc, val->pVertexInputState))
2380 vn_encode_VkPipelineVertexInputStateCreateInfo(enc, val->pVertexInputState);
2381 if (vn_encode_simple_pointer(enc, val->pInputAssemblyState))
2382 vn_encode_VkPipelineInputAssemblyStateCreateInfo(enc, val->pInputAssemblyState);
2383 if (vn_encode_simple_pointer(enc, val->pTessellationState))
2384 vn_encode_VkPipelineTessellationStateCreateInfo(enc, val->pTessellationState);
2385 if (vn_encode_simple_pointer(enc, val->pViewportState))
2386 vn_encode_VkPipelineViewportStateCreateInfo(enc, val->pViewportState);
2387 if (vn_encode_simple_pointer(enc, val->pRasterizationState))
2388 vn_encode_VkPipelineRasterizationStateCreateInfo(enc, val->pRasterizationState);
2389 if (vn_encode_simple_pointer(enc, val->pMultisampleState))
2390 vn_encode_VkPipelineMultisampleStateCreateInfo(enc, val->pMultisampleState);
2391 if (vn_encode_simple_pointer(enc, val->pDepthStencilState))
2392 vn_encode_VkPipelineDepthStencilStateCreateInfo(enc, val->pDepthStencilState);
2393 if (vn_encode_simple_pointer(enc, val->pColorBlendState))
2394 vn_encode_VkPipelineColorBlendStateCreateInfo(enc, val->pColorBlendState);
2395 if (vn_encode_simple_pointer(enc, val->pDynamicState))
2396 vn_encode_VkPipelineDynamicStateCreateInfo(enc, val->pDynamicState);
2397 vn_encode_VkPipelineLayout(enc, &val->layout);
2398 vn_encode_VkRenderPass(enc, &val->renderPass);
2399 vn_encode_uint32_t(enc, &val->subpass);
2400 vn_encode_VkPipeline(enc, &val->basePipelineHandle);
2401 vn_encode_int32_t(enc, &val->basePipelineIndex);
2402 }
2403
2404 static inline void
vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder * enc,const VkGraphicsPipelineCreateInfo * val)2405 vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
2406 {
2407 assert(val->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
2408 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO });
2409 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, val->pNext);
2410 vn_encode_VkGraphicsPipelineCreateInfo_self(enc, val);
2411 }
2412
2413 /* struct VkComputePipelineCreateInfo chain */
2414
2415 static inline size_t
vn_sizeof_VkComputePipelineCreateInfo_pnext(const void * val)2416 vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val)
2417 {
2418 const VkBaseInStructure *pnext = val;
2419 size_t size = 0;
2420
2421 while (pnext) {
2422 switch ((int32_t)pnext->sType) {
2423 case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
2424 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
2425 break;
2426 size += vn_sizeof_simple_pointer(pnext);
2427 size += vn_sizeof_VkStructureType(&pnext->sType);
2428 size += vn_sizeof_VkComputePipelineCreateInfo_pnext(pnext->pNext);
2429 size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self((const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
2430 return size;
2431 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
2432 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
2433 break;
2434 size += vn_sizeof_simple_pointer(pnext);
2435 size += vn_sizeof_VkStructureType(&pnext->sType);
2436 size += vn_sizeof_VkComputePipelineCreateInfo_pnext(pnext->pNext);
2437 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext);
2438 return size;
2439 default:
2440 /* ignore unknown/unsupported struct */
2441 break;
2442 }
2443 pnext = pnext->pNext;
2444 }
2445
2446 return vn_sizeof_simple_pointer(NULL);
2447 }
2448
2449 static inline size_t
vn_sizeof_VkComputePipelineCreateInfo_self(const VkComputePipelineCreateInfo * val)2450 vn_sizeof_VkComputePipelineCreateInfo_self(const VkComputePipelineCreateInfo *val)
2451 {
2452 size_t size = 0;
2453 /* skip val->{sType,pNext} */
2454 size += vn_sizeof_VkFlags(&val->flags);
2455 size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->stage);
2456 size += vn_sizeof_VkPipelineLayout(&val->layout);
2457 size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
2458 size += vn_sizeof_int32_t(&val->basePipelineIndex);
2459 return size;
2460 }
2461
2462 static inline size_t
vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo * val)2463 vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *val)
2464 {
2465 size_t size = 0;
2466
2467 size += vn_sizeof_VkStructureType(&val->sType);
2468 size += vn_sizeof_VkComputePipelineCreateInfo_pnext(val->pNext);
2469 size += vn_sizeof_VkComputePipelineCreateInfo_self(val);
2470
2471 return size;
2472 }
2473
2474 static inline void
vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)2475 vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
2476 {
2477 const VkBaseInStructure *pnext = val;
2478
2479 while (pnext) {
2480 switch ((int32_t)pnext->sType) {
2481 case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
2482 if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
2483 break;
2484 vn_encode_simple_pointer(enc, pnext);
2485 vn_encode_VkStructureType(enc, &pnext->sType);
2486 vn_encode_VkComputePipelineCreateInfo_pnext(enc, pnext->pNext);
2487 vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(enc, (const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
2488 return;
2489 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
2490 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
2491 break;
2492 vn_encode_simple_pointer(enc, pnext);
2493 vn_encode_VkStructureType(enc, &pnext->sType);
2494 vn_encode_VkComputePipelineCreateInfo_pnext(enc, pnext->pNext);
2495 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext);
2496 return;
2497 default:
2498 /* ignore unknown/unsupported struct */
2499 break;
2500 }
2501 pnext = pnext->pNext;
2502 }
2503
2504 vn_encode_simple_pointer(enc, NULL);
2505 }
2506
2507 static inline void
vn_encode_VkComputePipelineCreateInfo_self(struct vn_cs_encoder * enc,const VkComputePipelineCreateInfo * val)2508 vn_encode_VkComputePipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
2509 {
2510 /* skip val->{sType,pNext} */
2511 vn_encode_VkFlags(enc, &val->flags);
2512 vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->stage);
2513 vn_encode_VkPipelineLayout(enc, &val->layout);
2514 vn_encode_VkPipeline(enc, &val->basePipelineHandle);
2515 vn_encode_int32_t(enc, &val->basePipelineIndex);
2516 }
2517
2518 static inline void
vn_encode_VkComputePipelineCreateInfo(struct vn_cs_encoder * enc,const VkComputePipelineCreateInfo * val)2519 vn_encode_VkComputePipelineCreateInfo(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
2520 {
2521 assert(val->sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO);
2522 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO });
2523 vn_encode_VkComputePipelineCreateInfo_pnext(enc, val->pNext);
2524 vn_encode_VkComputePipelineCreateInfo_self(enc, val);
2525 }
2526
vn_sizeof_vkCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2527 static inline size_t vn_sizeof_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2528 {
2529 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
2530 const VkFlags cmd_flags = 0;
2531 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2532
2533 cmd_size += vn_sizeof_VkDevice(&device);
2534 cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
2535 cmd_size += vn_sizeof_uint32_t(&createInfoCount);
2536 if (pCreateInfos) {
2537 cmd_size += vn_sizeof_array_size(createInfoCount);
2538 for (uint32_t i = 0; i < createInfoCount; i++)
2539 cmd_size += vn_sizeof_VkGraphicsPipelineCreateInfo(&pCreateInfos[i]);
2540 } else {
2541 cmd_size += vn_sizeof_array_size(0);
2542 }
2543 cmd_size += vn_sizeof_simple_pointer(pAllocator);
2544 if (pAllocator)
2545 assert(false);
2546 if (pPipelines) {
2547 cmd_size += vn_sizeof_array_size(createInfoCount);
2548 for (uint32_t i = 0; i < createInfoCount; i++)
2549 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2550 } else {
2551 cmd_size += vn_sizeof_array_size(0);
2552 }
2553
2554 return cmd_size;
2555 }
2556
vn_encode_vkCreateGraphicsPipelines(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2557 static inline void vn_encode_vkCreateGraphicsPipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2558 {
2559 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
2560
2561 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2562 vn_encode_VkFlags(enc, &cmd_flags);
2563
2564 vn_encode_VkDevice(enc, &device);
2565 vn_encode_VkPipelineCache(enc, &pipelineCache);
2566 vn_encode_uint32_t(enc, &createInfoCount);
2567 if (pCreateInfos) {
2568 vn_encode_array_size(enc, createInfoCount);
2569 for (uint32_t i = 0; i < createInfoCount; i++)
2570 vn_encode_VkGraphicsPipelineCreateInfo(enc, &pCreateInfos[i]);
2571 } else {
2572 vn_encode_array_size(enc, 0);
2573 }
2574 if (vn_encode_simple_pointer(enc, pAllocator))
2575 assert(false);
2576 if (pPipelines) {
2577 vn_encode_array_size(enc, createInfoCount);
2578 for (uint32_t i = 0; i < createInfoCount; i++)
2579 vn_encode_VkPipeline(enc, &pPipelines[i]);
2580 } else {
2581 vn_encode_array_size(enc, 0);
2582 }
2583 }
2584
vn_sizeof_vkCreateGraphicsPipelines_reply(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2585 static inline size_t vn_sizeof_vkCreateGraphicsPipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2586 {
2587 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
2588 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2589
2590 VkResult ret;
2591 cmd_size += vn_sizeof_VkResult(&ret);
2592 /* skip device */
2593 /* skip pipelineCache */
2594 /* skip createInfoCount */
2595 /* skip pCreateInfos */
2596 /* skip pAllocator */
2597 if (pPipelines) {
2598 cmd_size += vn_sizeof_array_size(createInfoCount);
2599 for (uint32_t i = 0; i < createInfoCount; i++)
2600 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2601 } else {
2602 cmd_size += vn_sizeof_array_size(0);
2603 }
2604
2605 return cmd_size;
2606 }
2607
vn_decode_vkCreateGraphicsPipelines_reply(struct vn_cs_decoder * dec,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2608 static inline VkResult vn_decode_vkCreateGraphicsPipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2609 {
2610 VkCommandTypeEXT command_type;
2611 vn_decode_VkCommandTypeEXT(dec, &command_type);
2612 assert(command_type == VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT);
2613
2614 VkResult ret;
2615 vn_decode_VkResult(dec, &ret);
2616 /* skip device */
2617 /* skip pipelineCache */
2618 /* skip createInfoCount */
2619 /* skip pCreateInfos */
2620 /* skip pAllocator */
2621 if (vn_peek_array_size(dec)) {
2622 const uint32_t iter_count = vn_decode_array_size(dec, createInfoCount);
2623 for (uint32_t i = 0; i < iter_count; i++)
2624 vn_decode_VkPipeline(dec, &pPipelines[i]);
2625 } else {
2626 vn_decode_array_size_unchecked(dec);
2627 pPipelines = NULL;
2628 }
2629
2630 return ret;
2631 }
2632
vn_sizeof_vkCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2633 static inline size_t vn_sizeof_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2634 {
2635 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
2636 const VkFlags cmd_flags = 0;
2637 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2638
2639 cmd_size += vn_sizeof_VkDevice(&device);
2640 cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
2641 cmd_size += vn_sizeof_uint32_t(&createInfoCount);
2642 if (pCreateInfos) {
2643 cmd_size += vn_sizeof_array_size(createInfoCount);
2644 for (uint32_t i = 0; i < createInfoCount; i++)
2645 cmd_size += vn_sizeof_VkComputePipelineCreateInfo(&pCreateInfos[i]);
2646 } else {
2647 cmd_size += vn_sizeof_array_size(0);
2648 }
2649 cmd_size += vn_sizeof_simple_pointer(pAllocator);
2650 if (pAllocator)
2651 assert(false);
2652 if (pPipelines) {
2653 cmd_size += vn_sizeof_array_size(createInfoCount);
2654 for (uint32_t i = 0; i < createInfoCount; i++)
2655 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2656 } else {
2657 cmd_size += vn_sizeof_array_size(0);
2658 }
2659
2660 return cmd_size;
2661 }
2662
vn_encode_vkCreateComputePipelines(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2663 static inline void vn_encode_vkCreateComputePipelines(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2664 {
2665 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
2666
2667 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2668 vn_encode_VkFlags(enc, &cmd_flags);
2669
2670 vn_encode_VkDevice(enc, &device);
2671 vn_encode_VkPipelineCache(enc, &pipelineCache);
2672 vn_encode_uint32_t(enc, &createInfoCount);
2673 if (pCreateInfos) {
2674 vn_encode_array_size(enc, createInfoCount);
2675 for (uint32_t i = 0; i < createInfoCount; i++)
2676 vn_encode_VkComputePipelineCreateInfo(enc, &pCreateInfos[i]);
2677 } else {
2678 vn_encode_array_size(enc, 0);
2679 }
2680 if (vn_encode_simple_pointer(enc, pAllocator))
2681 assert(false);
2682 if (pPipelines) {
2683 vn_encode_array_size(enc, createInfoCount);
2684 for (uint32_t i = 0; i < createInfoCount; i++)
2685 vn_encode_VkPipeline(enc, &pPipelines[i]);
2686 } else {
2687 vn_encode_array_size(enc, 0);
2688 }
2689 }
2690
vn_sizeof_vkCreateComputePipelines_reply(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2691 static inline size_t vn_sizeof_vkCreateComputePipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2692 {
2693 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
2694 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2695
2696 VkResult ret;
2697 cmd_size += vn_sizeof_VkResult(&ret);
2698 /* skip device */
2699 /* skip pipelineCache */
2700 /* skip createInfoCount */
2701 /* skip pCreateInfos */
2702 /* skip pAllocator */
2703 if (pPipelines) {
2704 cmd_size += vn_sizeof_array_size(createInfoCount);
2705 for (uint32_t i = 0; i < createInfoCount; i++)
2706 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2707 } else {
2708 cmd_size += vn_sizeof_array_size(0);
2709 }
2710
2711 return cmd_size;
2712 }
2713
vn_decode_vkCreateComputePipelines_reply(struct vn_cs_decoder * dec,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2714 static inline VkResult vn_decode_vkCreateComputePipelines_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2715 {
2716 VkCommandTypeEXT command_type;
2717 vn_decode_VkCommandTypeEXT(dec, &command_type);
2718 assert(command_type == VK_COMMAND_TYPE_vkCreateComputePipelines_EXT);
2719
2720 VkResult ret;
2721 vn_decode_VkResult(dec, &ret);
2722 /* skip device */
2723 /* skip pipelineCache */
2724 /* skip createInfoCount */
2725 /* skip pCreateInfos */
2726 /* skip pAllocator */
2727 if (vn_peek_array_size(dec)) {
2728 const uint32_t iter_count = vn_decode_array_size(dec, createInfoCount);
2729 for (uint32_t i = 0; i < iter_count; i++)
2730 vn_decode_VkPipeline(dec, &pPipelines[i]);
2731 } else {
2732 vn_decode_array_size_unchecked(dec);
2733 pPipelines = NULL;
2734 }
2735
2736 return ret;
2737 }
2738
vn_sizeof_vkDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2739 static inline size_t vn_sizeof_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2740 {
2741 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
2742 const VkFlags cmd_flags = 0;
2743 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2744
2745 cmd_size += vn_sizeof_VkDevice(&device);
2746 cmd_size += vn_sizeof_VkPipeline(&pipeline);
2747 cmd_size += vn_sizeof_simple_pointer(pAllocator);
2748 if (pAllocator)
2749 assert(false);
2750
2751 return cmd_size;
2752 }
2753
vn_encode_vkDestroyPipeline(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2754 static inline void vn_encode_vkDestroyPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2755 {
2756 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
2757
2758 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2759 vn_encode_VkFlags(enc, &cmd_flags);
2760
2761 vn_encode_VkDevice(enc, &device);
2762 vn_encode_VkPipeline(enc, &pipeline);
2763 if (vn_encode_simple_pointer(enc, pAllocator))
2764 assert(false);
2765 }
2766
vn_sizeof_vkDestroyPipeline_reply(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2767 static inline size_t vn_sizeof_vkDestroyPipeline_reply(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2768 {
2769 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
2770 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2771
2772 /* skip device */
2773 /* skip pipeline */
2774 /* skip pAllocator */
2775
2776 return cmd_size;
2777 }
2778
vn_decode_vkDestroyPipeline_reply(struct vn_cs_decoder * dec,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2779 static inline void vn_decode_vkDestroyPipeline_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2780 {
2781 VkCommandTypeEXT command_type;
2782 vn_decode_VkCommandTypeEXT(dec, &command_type);
2783 assert(command_type == VK_COMMAND_TYPE_vkDestroyPipeline_EXT);
2784
2785 /* skip device */
2786 /* skip pipeline */
2787 /* skip pAllocator */
2788 }
2789
vn_submit_vkCreateGraphicsPipelines(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,struct vn_ring_submit_command * submit)2790 static inline void vn_submit_vkCreateGraphicsPipelines(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_ring_submit_command *submit)
2791 {
2792 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2793 void *cmd_data = local_cmd_data;
2794 size_t cmd_size = vn_sizeof_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2795 if (cmd_size > sizeof(local_cmd_data)) {
2796 cmd_data = malloc(cmd_size);
2797 if (!cmd_data)
2798 cmd_size = 0;
2799 }
2800 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateGraphicsPipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
2801
2802 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2803 if (cmd_size) {
2804 vn_encode_vkCreateGraphicsPipelines(enc, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2805 vn_ring_submit_command(vn_ring, submit);
2806 if (cmd_data != local_cmd_data)
2807 free(cmd_data);
2808 }
2809 }
2810
vn_submit_vkCreateComputePipelines(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,struct vn_ring_submit_command * submit)2811 static inline void vn_submit_vkCreateComputePipelines(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_ring_submit_command *submit)
2812 {
2813 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2814 void *cmd_data = local_cmd_data;
2815 size_t cmd_size = vn_sizeof_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2816 if (cmd_size > sizeof(local_cmd_data)) {
2817 cmd_data = malloc(cmd_size);
2818 if (!cmd_data)
2819 cmd_size = 0;
2820 }
2821 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateComputePipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
2822
2823 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2824 if (cmd_size) {
2825 vn_encode_vkCreateComputePipelines(enc, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2826 vn_ring_submit_command(vn_ring, submit);
2827 if (cmd_data != local_cmd_data)
2828 free(cmd_data);
2829 }
2830 }
2831
vn_submit_vkDestroyPipeline(struct vn_ring * vn_ring,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator,struct vn_ring_submit_command * submit)2832 static inline void vn_submit_vkDestroyPipeline(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator, struct vn_ring_submit_command *submit)
2833 {
2834 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2835 void *cmd_data = local_cmd_data;
2836 size_t cmd_size = vn_sizeof_vkDestroyPipeline(device, pipeline, pAllocator);
2837 if (cmd_size > sizeof(local_cmd_data)) {
2838 cmd_data = malloc(cmd_size);
2839 if (!cmd_data)
2840 cmd_size = 0;
2841 }
2842 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipeline_reply(device, pipeline, pAllocator) : 0;
2843
2844 struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
2845 if (cmd_size) {
2846 vn_encode_vkDestroyPipeline(enc, cmd_flags, device, pipeline, pAllocator);
2847 vn_ring_submit_command(vn_ring, submit);
2848 if (cmd_data != local_cmd_data)
2849 free(cmd_data);
2850 }
2851 }
2852
vn_call_vkCreateGraphicsPipelines(struct vn_ring * vn_ring,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2853 static inline VkResult vn_call_vkCreateGraphicsPipelines(struct vn_ring *vn_ring, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2854 {
2855 VN_TRACE_FUNC();
2856
2857 struct vn_ring_submit_command submit;
2858 vn_submit_vkCreateGraphicsPipelines(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2859 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2860 if (dec) {
2861 const VkResult ret = vn_decode_vkCreateGraphicsPipelines_reply(dec, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2862 vn_ring_free_command_reply(vn_ring, &submit);
2863 return ret;
2864 } else {
2865 return VK_ERROR_OUT_OF_HOST_MEMORY;
2866 }
2867 }
2868
vn_async_vkCreateGraphicsPipelines(struct vn_ring * vn_ring,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2869 static inline void vn_async_vkCreateGraphicsPipelines(struct vn_ring *vn_ring, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2870 {
2871 struct vn_ring_submit_command submit;
2872 vn_submit_vkCreateGraphicsPipelines(vn_ring, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2873 }
2874
vn_call_vkCreateComputePipelines(struct vn_ring * vn_ring,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2875 static inline VkResult vn_call_vkCreateComputePipelines(struct vn_ring *vn_ring, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2876 {
2877 VN_TRACE_FUNC();
2878
2879 struct vn_ring_submit_command submit;
2880 vn_submit_vkCreateComputePipelines(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2881 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2882 if (dec) {
2883 const VkResult ret = vn_decode_vkCreateComputePipelines_reply(dec, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2884 vn_ring_free_command_reply(vn_ring, &submit);
2885 return ret;
2886 } else {
2887 return VK_ERROR_OUT_OF_HOST_MEMORY;
2888 }
2889 }
2890
vn_async_vkCreateComputePipelines(struct vn_ring * vn_ring,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2891 static inline void vn_async_vkCreateComputePipelines(struct vn_ring *vn_ring, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2892 {
2893 struct vn_ring_submit_command submit;
2894 vn_submit_vkCreateComputePipelines(vn_ring, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2895 }
2896
vn_call_vkDestroyPipeline(struct vn_ring * vn_ring,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2897 static inline void vn_call_vkDestroyPipeline(struct vn_ring *vn_ring, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2898 {
2899 VN_TRACE_FUNC();
2900
2901 struct vn_ring_submit_command submit;
2902 vn_submit_vkDestroyPipeline(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipeline, pAllocator, &submit);
2903 struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
2904 if (dec) {
2905 vn_decode_vkDestroyPipeline_reply(dec, device, pipeline, pAllocator);
2906 vn_ring_free_command_reply(vn_ring, &submit);
2907 }
2908 }
2909
vn_async_vkDestroyPipeline(struct vn_ring * vn_ring,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2910 static inline void vn_async_vkDestroyPipeline(struct vn_ring *vn_ring, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2911 {
2912 struct vn_ring_submit_command submit;
2913 vn_submit_vkDestroyPipeline(vn_ring, 0, device, pipeline, pAllocator, &submit);
2914 }
2915
2916 #endif /* VN_PROTOCOL_DRIVER_PIPELINE_H */
2917