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_instance.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_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
142 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
143 break;
144 size += vn_sizeof_simple_pointer(pnext);
145 size += vn_sizeof_VkStructureType(&pnext->sType);
146 size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(pnext->pNext);
147 size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self((const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
148 return size;
149 default:
150 /* ignore unknown/unsupported struct */
151 break;
152 }
153 pnext = pnext->pNext;
154 }
155
156 return vn_sizeof_simple_pointer(NULL);
157 }
158
159 static inline size_t
vn_sizeof_VkPipelineShaderStageCreateInfo_self(const VkPipelineShaderStageCreateInfo * val)160 vn_sizeof_VkPipelineShaderStageCreateInfo_self(const VkPipelineShaderStageCreateInfo *val)
161 {
162 size_t size = 0;
163 /* skip val->{sType,pNext} */
164 size += vn_sizeof_VkFlags(&val->flags);
165 size += vn_sizeof_VkShaderStageFlagBits(&val->stage);
166 size += vn_sizeof_VkShaderModule(&val->module);
167 if (val->pName) {
168 const size_t string_size = strlen(val->pName) + 1;
169 size += vn_sizeof_array_size(string_size);
170 size += vn_sizeof_char_array(val->pName, string_size);
171 } else {
172 size += vn_sizeof_array_size(0);
173 }
174 size += vn_sizeof_simple_pointer(val->pSpecializationInfo);
175 if (val->pSpecializationInfo)
176 size += vn_sizeof_VkSpecializationInfo(val->pSpecializationInfo);
177 return size;
178 }
179
180 static inline size_t
vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo * val)181 vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo *val)
182 {
183 size_t size = 0;
184
185 size += vn_sizeof_VkStructureType(&val->sType);
186 size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(val->pNext);
187 size += vn_sizeof_VkPipelineShaderStageCreateInfo_self(val);
188
189 return size;
190 }
191
192 static inline void
vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)193 vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
194 {
195 const VkBaseInStructure *pnext = val;
196
197 while (pnext) {
198 switch ((int32_t)pnext->sType) {
199 case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
200 if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
201 break;
202 vn_encode_simple_pointer(enc, pnext);
203 vn_encode_VkStructureType(enc, &pnext->sType);
204 vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, pnext->pNext);
205 vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(enc, (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
206 return;
207 default:
208 /* ignore unknown/unsupported struct */
209 break;
210 }
211 pnext = pnext->pNext;
212 }
213
214 vn_encode_simple_pointer(enc, NULL);
215 }
216
217 static inline void
vn_encode_VkPipelineShaderStageCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineShaderStageCreateInfo * val)218 vn_encode_VkPipelineShaderStageCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
219 {
220 /* skip val->{sType,pNext} */
221 vn_encode_VkFlags(enc, &val->flags);
222 vn_encode_VkShaderStageFlagBits(enc, &val->stage);
223 vn_encode_VkShaderModule(enc, &val->module);
224 if (val->pName) {
225 const size_t string_size = strlen(val->pName) + 1;
226 vn_encode_array_size(enc, string_size);
227 vn_encode_char_array(enc, val->pName, string_size);
228 } else {
229 vn_encode_array_size(enc, 0);
230 }
231 if (vn_encode_simple_pointer(enc, val->pSpecializationInfo))
232 vn_encode_VkSpecializationInfo(enc, val->pSpecializationInfo);
233 }
234
235 static inline void
vn_encode_VkPipelineShaderStageCreateInfo(struct vn_cs_encoder * enc,const VkPipelineShaderStageCreateInfo * val)236 vn_encode_VkPipelineShaderStageCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageCreateInfo *val)
237 {
238 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO);
239 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO });
240 vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, val->pNext);
241 vn_encode_VkPipelineShaderStageCreateInfo_self(enc, val);
242 }
243
244 /* struct VkVertexInputBindingDescription */
245
246 static inline size_t
vn_sizeof_VkVertexInputBindingDescription(const VkVertexInputBindingDescription * val)247 vn_sizeof_VkVertexInputBindingDescription(const VkVertexInputBindingDescription *val)
248 {
249 size_t size = 0;
250 size += vn_sizeof_uint32_t(&val->binding);
251 size += vn_sizeof_uint32_t(&val->stride);
252 size += vn_sizeof_VkVertexInputRate(&val->inputRate);
253 return size;
254 }
255
256 static inline void
vn_encode_VkVertexInputBindingDescription(struct vn_cs_encoder * enc,const VkVertexInputBindingDescription * val)257 vn_encode_VkVertexInputBindingDescription(struct vn_cs_encoder *enc, const VkVertexInputBindingDescription *val)
258 {
259 vn_encode_uint32_t(enc, &val->binding);
260 vn_encode_uint32_t(enc, &val->stride);
261 vn_encode_VkVertexInputRate(enc, &val->inputRate);
262 }
263
264 /* struct VkVertexInputAttributeDescription */
265
266 static inline size_t
vn_sizeof_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription * val)267 vn_sizeof_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription *val)
268 {
269 size_t size = 0;
270 size += vn_sizeof_uint32_t(&val->location);
271 size += vn_sizeof_uint32_t(&val->binding);
272 size += vn_sizeof_VkFormat(&val->format);
273 size += vn_sizeof_uint32_t(&val->offset);
274 return size;
275 }
276
277 static inline void
vn_encode_VkVertexInputAttributeDescription(struct vn_cs_encoder * enc,const VkVertexInputAttributeDescription * val)278 vn_encode_VkVertexInputAttributeDescription(struct vn_cs_encoder *enc, const VkVertexInputAttributeDescription *val)
279 {
280 vn_encode_uint32_t(enc, &val->location);
281 vn_encode_uint32_t(enc, &val->binding);
282 vn_encode_VkFormat(enc, &val->format);
283 vn_encode_uint32_t(enc, &val->offset);
284 }
285
286 /* struct VkVertexInputBindingDivisorDescriptionEXT */
287
288 static inline size_t
vn_sizeof_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT * val)289 vn_sizeof_VkVertexInputBindingDivisorDescriptionEXT(const VkVertexInputBindingDivisorDescriptionEXT *val)
290 {
291 size_t size = 0;
292 size += vn_sizeof_uint32_t(&val->binding);
293 size += vn_sizeof_uint32_t(&val->divisor);
294 return size;
295 }
296
297 static inline void
vn_encode_VkVertexInputBindingDivisorDescriptionEXT(struct vn_cs_encoder * enc,const VkVertexInputBindingDivisorDescriptionEXT * val)298 vn_encode_VkVertexInputBindingDivisorDescriptionEXT(struct vn_cs_encoder *enc, const VkVertexInputBindingDivisorDescriptionEXT *val)
299 {
300 vn_encode_uint32_t(enc, &val->binding);
301 vn_encode_uint32_t(enc, &val->divisor);
302 }
303
304 /* struct VkPipelineVertexInputDivisorStateCreateInfoEXT chain */
305
306 static inline size_t
vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(const void * val)307 vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(const void *val)
308 {
309 /* no known/supported struct */
310 return vn_sizeof_simple_pointer(NULL);
311 }
312
313 static inline size_t
vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)314 vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
315 {
316 size_t size = 0;
317 /* skip val->{sType,pNext} */
318 size += vn_sizeof_uint32_t(&val->vertexBindingDivisorCount);
319 if (val->pVertexBindingDivisors) {
320 size += vn_sizeof_array_size(val->vertexBindingDivisorCount);
321 for (uint32_t i = 0; i < val->vertexBindingDivisorCount; i++)
322 size += vn_sizeof_VkVertexInputBindingDivisorDescriptionEXT(&val->pVertexBindingDivisors[i]);
323 } else {
324 size += vn_sizeof_array_size(0);
325 }
326 return size;
327 }
328
329 static inline size_t
vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)330 vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
331 {
332 size_t size = 0;
333
334 size += vn_sizeof_VkStructureType(&val->sType);
335 size += vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(val->pNext);
336 size += vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(val);
337
338 return size;
339 }
340
341 static inline void
vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)342 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
343 {
344 /* no known/supported struct */
345 vn_encode_simple_pointer(enc, NULL);
346 }
347
348 static inline void
vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)349 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
350 {
351 /* skip val->{sType,pNext} */
352 vn_encode_uint32_t(enc, &val->vertexBindingDivisorCount);
353 if (val->pVertexBindingDivisors) {
354 vn_encode_array_size(enc, val->vertexBindingDivisorCount);
355 for (uint32_t i = 0; i < val->vertexBindingDivisorCount; i++)
356 vn_encode_VkVertexInputBindingDivisorDescriptionEXT(enc, &val->pVertexBindingDivisors[i]);
357 } else {
358 vn_encode_array_size(enc, 0);
359 }
360 }
361
362 static inline void
vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineVertexInputDivisorStateCreateInfoEXT * val)363 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineVertexInputDivisorStateCreateInfoEXT *val)
364 {
365 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT);
366 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT });
367 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_pnext(enc, val->pNext);
368 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(enc, val);
369 }
370
371 /* struct VkPipelineVertexInputStateCreateInfo chain */
372
373 static inline size_t
vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(const void * val)374 vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(const void *val)
375 {
376 const VkBaseInStructure *pnext = val;
377 size_t size = 0;
378
379 while (pnext) {
380 switch ((int32_t)pnext->sType) {
381 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
382 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
383 break;
384 size += vn_sizeof_simple_pointer(pnext);
385 size += vn_sizeof_VkStructureType(&pnext->sType);
386 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(pnext->pNext);
387 size += vn_sizeof_VkPipelineVertexInputDivisorStateCreateInfoEXT_self((const VkPipelineVertexInputDivisorStateCreateInfoEXT *)pnext);
388 return size;
389 default:
390 /* ignore unknown/unsupported struct */
391 break;
392 }
393 pnext = pnext->pNext;
394 }
395
396 return vn_sizeof_simple_pointer(NULL);
397 }
398
399 static inline size_t
vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(const VkPipelineVertexInputStateCreateInfo * val)400 vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(const VkPipelineVertexInputStateCreateInfo *val)
401 {
402 size_t size = 0;
403 /* skip val->{sType,pNext} */
404 size += vn_sizeof_VkFlags(&val->flags);
405 size += vn_sizeof_uint32_t(&val->vertexBindingDescriptionCount);
406 if (val->pVertexBindingDescriptions) {
407 size += vn_sizeof_array_size(val->vertexBindingDescriptionCount);
408 for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
409 size += vn_sizeof_VkVertexInputBindingDescription(&val->pVertexBindingDescriptions[i]);
410 } else {
411 size += vn_sizeof_array_size(0);
412 }
413 size += vn_sizeof_uint32_t(&val->vertexAttributeDescriptionCount);
414 if (val->pVertexAttributeDescriptions) {
415 size += vn_sizeof_array_size(val->vertexAttributeDescriptionCount);
416 for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
417 size += vn_sizeof_VkVertexInputAttributeDescription(&val->pVertexAttributeDescriptions[i]);
418 } else {
419 size += vn_sizeof_array_size(0);
420 }
421 return size;
422 }
423
424 static inline size_t
vn_sizeof_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo * val)425 vn_sizeof_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo *val)
426 {
427 size_t size = 0;
428
429 size += vn_sizeof_VkStructureType(&val->sType);
430 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_pnext(val->pNext);
431 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo_self(val);
432
433 return size;
434 }
435
436 static inline void
vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)437 vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
438 {
439 const VkBaseInStructure *pnext = val;
440
441 while (pnext) {
442 switch ((int32_t)pnext->sType) {
443 case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
444 if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
445 break;
446 vn_encode_simple_pointer(enc, pnext);
447 vn_encode_VkStructureType(enc, &pnext->sType);
448 vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(enc, pnext->pNext);
449 vn_encode_VkPipelineVertexInputDivisorStateCreateInfoEXT_self(enc, (const VkPipelineVertexInputDivisorStateCreateInfoEXT *)pnext);
450 return;
451 default:
452 /* ignore unknown/unsupported struct */
453 break;
454 }
455 pnext = pnext->pNext;
456 }
457
458 vn_encode_simple_pointer(enc, NULL);
459 }
460
461 static inline void
vn_encode_VkPipelineVertexInputStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineVertexInputStateCreateInfo * val)462 vn_encode_VkPipelineVertexInputStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
463 {
464 /* skip val->{sType,pNext} */
465 vn_encode_VkFlags(enc, &val->flags);
466 vn_encode_uint32_t(enc, &val->vertexBindingDescriptionCount);
467 if (val->pVertexBindingDescriptions) {
468 vn_encode_array_size(enc, val->vertexBindingDescriptionCount);
469 for (uint32_t i = 0; i < val->vertexBindingDescriptionCount; i++)
470 vn_encode_VkVertexInputBindingDescription(enc, &val->pVertexBindingDescriptions[i]);
471 } else {
472 vn_encode_array_size(enc, 0);
473 }
474 vn_encode_uint32_t(enc, &val->vertexAttributeDescriptionCount);
475 if (val->pVertexAttributeDescriptions) {
476 vn_encode_array_size(enc, val->vertexAttributeDescriptionCount);
477 for (uint32_t i = 0; i < val->vertexAttributeDescriptionCount; i++)
478 vn_encode_VkVertexInputAttributeDescription(enc, &val->pVertexAttributeDescriptions[i]);
479 } else {
480 vn_encode_array_size(enc, 0);
481 }
482 }
483
484 static inline void
vn_encode_VkPipelineVertexInputStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineVertexInputStateCreateInfo * val)485 vn_encode_VkPipelineVertexInputStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineVertexInputStateCreateInfo *val)
486 {
487 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO);
488 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO });
489 vn_encode_VkPipelineVertexInputStateCreateInfo_pnext(enc, val->pNext);
490 vn_encode_VkPipelineVertexInputStateCreateInfo_self(enc, val);
491 }
492
493 /* struct VkPipelineInputAssemblyStateCreateInfo chain */
494
495 static inline size_t
vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(const void * val)496 vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(const void *val)
497 {
498 /* no known/supported struct */
499 return vn_sizeof_simple_pointer(NULL);
500 }
501
502 static inline size_t
vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(const VkPipelineInputAssemblyStateCreateInfo * val)503 vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(const VkPipelineInputAssemblyStateCreateInfo *val)
504 {
505 size_t size = 0;
506 /* skip val->{sType,pNext} */
507 size += vn_sizeof_VkFlags(&val->flags);
508 size += vn_sizeof_VkPrimitiveTopology(&val->topology);
509 size += vn_sizeof_VkBool32(&val->primitiveRestartEnable);
510 return size;
511 }
512
513 static inline size_t
vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo * val)514 vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo *val)
515 {
516 size_t size = 0;
517
518 size += vn_sizeof_VkStructureType(&val->sType);
519 size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_pnext(val->pNext);
520 size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo_self(val);
521
522 return size;
523 }
524
525 static inline void
vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)526 vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
527 {
528 /* no known/supported struct */
529 vn_encode_simple_pointer(enc, NULL);
530 }
531
532 static inline void
vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineInputAssemblyStateCreateInfo * val)533 vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
534 {
535 /* skip val->{sType,pNext} */
536 vn_encode_VkFlags(enc, &val->flags);
537 vn_encode_VkPrimitiveTopology(enc, &val->topology);
538 vn_encode_VkBool32(enc, &val->primitiveRestartEnable);
539 }
540
541 static inline void
vn_encode_VkPipelineInputAssemblyStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineInputAssemblyStateCreateInfo * val)542 vn_encode_VkPipelineInputAssemblyStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineInputAssemblyStateCreateInfo *val)
543 {
544 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO);
545 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO });
546 vn_encode_VkPipelineInputAssemblyStateCreateInfo_pnext(enc, val->pNext);
547 vn_encode_VkPipelineInputAssemblyStateCreateInfo_self(enc, val);
548 }
549
550 /* struct VkPipelineTessellationDomainOriginStateCreateInfo chain */
551
552 static inline size_t
vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(const void * val)553 vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(const void *val)
554 {
555 /* no known/supported struct */
556 return vn_sizeof_simple_pointer(NULL);
557 }
558
559 static inline size_t
vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(const VkPipelineTessellationDomainOriginStateCreateInfo * val)560 vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
561 {
562 size_t size = 0;
563 /* skip val->{sType,pNext} */
564 size += vn_sizeof_VkTessellationDomainOrigin(&val->domainOrigin);
565 return size;
566 }
567
568 static inline size_t
vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo * val)569 vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo *val)
570 {
571 size_t size = 0;
572
573 size += vn_sizeof_VkStructureType(&val->sType);
574 size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(val->pNext);
575 size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self(val);
576
577 return size;
578 }
579
580 static inline void
vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)581 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
582 {
583 /* no known/supported struct */
584 vn_encode_simple_pointer(enc, NULL);
585 }
586
587 static inline void
vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineTessellationDomainOriginStateCreateInfo * val)588 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
589 {
590 /* skip val->{sType,pNext} */
591 vn_encode_VkTessellationDomainOrigin(enc, &val->domainOrigin);
592 }
593
594 static inline void
vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineTessellationDomainOriginStateCreateInfo * val)595 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationDomainOriginStateCreateInfo *val)
596 {
597 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO);
598 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO });
599 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_pnext(enc, val->pNext);
600 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, val);
601 }
602
603 /* struct VkPipelineTessellationStateCreateInfo chain */
604
605 static inline size_t
vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(const void * val)606 vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(const void *val)
607 {
608 const VkBaseInStructure *pnext = val;
609 size_t size = 0;
610
611 while (pnext) {
612 switch ((int32_t)pnext->sType) {
613 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
614 size += vn_sizeof_simple_pointer(pnext);
615 size += vn_sizeof_VkStructureType(&pnext->sType);
616 size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(pnext->pNext);
617 size += vn_sizeof_VkPipelineTessellationDomainOriginStateCreateInfo_self((const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
618 return size;
619 default:
620 /* ignore unknown/unsupported struct */
621 break;
622 }
623 pnext = pnext->pNext;
624 }
625
626 return vn_sizeof_simple_pointer(NULL);
627 }
628
629 static inline size_t
vn_sizeof_VkPipelineTessellationStateCreateInfo_self(const VkPipelineTessellationStateCreateInfo * val)630 vn_sizeof_VkPipelineTessellationStateCreateInfo_self(const VkPipelineTessellationStateCreateInfo *val)
631 {
632 size_t size = 0;
633 /* skip val->{sType,pNext} */
634 size += vn_sizeof_VkFlags(&val->flags);
635 size += vn_sizeof_uint32_t(&val->patchControlPoints);
636 return size;
637 }
638
639 static inline size_t
vn_sizeof_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo * val)640 vn_sizeof_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo *val)
641 {
642 size_t size = 0;
643
644 size += vn_sizeof_VkStructureType(&val->sType);
645 size += vn_sizeof_VkPipelineTessellationStateCreateInfo_pnext(val->pNext);
646 size += vn_sizeof_VkPipelineTessellationStateCreateInfo_self(val);
647
648 return size;
649 }
650
651 static inline void
vn_encode_VkPipelineTessellationStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)652 vn_encode_VkPipelineTessellationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
653 {
654 const VkBaseInStructure *pnext = val;
655
656 while (pnext) {
657 switch ((int32_t)pnext->sType) {
658 case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
659 vn_encode_simple_pointer(enc, pnext);
660 vn_encode_VkStructureType(enc, &pnext->sType);
661 vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, pnext->pNext);
662 vn_encode_VkPipelineTessellationDomainOriginStateCreateInfo_self(enc, (const VkPipelineTessellationDomainOriginStateCreateInfo *)pnext);
663 return;
664 default:
665 /* ignore unknown/unsupported struct */
666 break;
667 }
668 pnext = pnext->pNext;
669 }
670
671 vn_encode_simple_pointer(enc, NULL);
672 }
673
674 static inline void
vn_encode_VkPipelineTessellationStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineTessellationStateCreateInfo * val)675 vn_encode_VkPipelineTessellationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
676 {
677 /* skip val->{sType,pNext} */
678 vn_encode_VkFlags(enc, &val->flags);
679 vn_encode_uint32_t(enc, &val->patchControlPoints);
680 }
681
682 static inline void
vn_encode_VkPipelineTessellationStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineTessellationStateCreateInfo * val)683 vn_encode_VkPipelineTessellationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineTessellationStateCreateInfo *val)
684 {
685 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO);
686 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO });
687 vn_encode_VkPipelineTessellationStateCreateInfo_pnext(enc, val->pNext);
688 vn_encode_VkPipelineTessellationStateCreateInfo_self(enc, val);
689 }
690
691 /* struct VkPipelineViewportStateCreateInfo chain */
692
693 static inline size_t
vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(const void * val)694 vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(const void *val)
695 {
696 /* no known/supported struct */
697 return vn_sizeof_simple_pointer(NULL);
698 }
699
700 static inline size_t
vn_sizeof_VkPipelineViewportStateCreateInfo_self(const VkPipelineViewportStateCreateInfo * val)701 vn_sizeof_VkPipelineViewportStateCreateInfo_self(const VkPipelineViewportStateCreateInfo *val)
702 {
703 size_t size = 0;
704 /* skip val->{sType,pNext} */
705 size += vn_sizeof_VkFlags(&val->flags);
706 size += vn_sizeof_uint32_t(&val->viewportCount);
707 if (val->pViewports) {
708 size += vn_sizeof_array_size(val->viewportCount);
709 for (uint32_t i = 0; i < val->viewportCount; i++)
710 size += vn_sizeof_VkViewport(&val->pViewports[i]);
711 } else {
712 size += vn_sizeof_array_size(0);
713 }
714 size += vn_sizeof_uint32_t(&val->scissorCount);
715 if (val->pScissors) {
716 size += vn_sizeof_array_size(val->scissorCount);
717 for (uint32_t i = 0; i < val->scissorCount; i++)
718 size += vn_sizeof_VkRect2D(&val->pScissors[i]);
719 } else {
720 size += vn_sizeof_array_size(0);
721 }
722 return size;
723 }
724
725 static inline size_t
vn_sizeof_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo * val)726 vn_sizeof_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo *val)
727 {
728 size_t size = 0;
729
730 size += vn_sizeof_VkStructureType(&val->sType);
731 size += vn_sizeof_VkPipelineViewportStateCreateInfo_pnext(val->pNext);
732 size += vn_sizeof_VkPipelineViewportStateCreateInfo_self(val);
733
734 return size;
735 }
736
737 static inline void
vn_encode_VkPipelineViewportStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)738 vn_encode_VkPipelineViewportStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
739 {
740 /* no known/supported struct */
741 vn_encode_simple_pointer(enc, NULL);
742 }
743
744 static inline void
vn_encode_VkPipelineViewportStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineViewportStateCreateInfo * val)745 vn_encode_VkPipelineViewportStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
746 {
747 /* skip val->{sType,pNext} */
748 vn_encode_VkFlags(enc, &val->flags);
749 vn_encode_uint32_t(enc, &val->viewportCount);
750 if (val->pViewports) {
751 vn_encode_array_size(enc, val->viewportCount);
752 for (uint32_t i = 0; i < val->viewportCount; i++)
753 vn_encode_VkViewport(enc, &val->pViewports[i]);
754 } else {
755 vn_encode_array_size(enc, 0);
756 }
757 vn_encode_uint32_t(enc, &val->scissorCount);
758 if (val->pScissors) {
759 vn_encode_array_size(enc, val->scissorCount);
760 for (uint32_t i = 0; i < val->scissorCount; i++)
761 vn_encode_VkRect2D(enc, &val->pScissors[i]);
762 } else {
763 vn_encode_array_size(enc, 0);
764 }
765 }
766
767 static inline void
vn_encode_VkPipelineViewportStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineViewportStateCreateInfo * val)768 vn_encode_VkPipelineViewportStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineViewportStateCreateInfo *val)
769 {
770 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO);
771 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO });
772 vn_encode_VkPipelineViewportStateCreateInfo_pnext(enc, val->pNext);
773 vn_encode_VkPipelineViewportStateCreateInfo_self(enc, val);
774 }
775
776 /* struct VkPipelineRasterizationConservativeStateCreateInfoEXT chain */
777
778 static inline size_t
vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(const void * val)779 vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(const void *val)
780 {
781 /* no known/supported struct */
782 return vn_sizeof_simple_pointer(NULL);
783 }
784
785 static inline size_t
vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)786 vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
787 {
788 size_t size = 0;
789 /* skip val->{sType,pNext} */
790 size += vn_sizeof_VkFlags(&val->flags);
791 size += vn_sizeof_VkConservativeRasterizationModeEXT(&val->conservativeRasterizationMode);
792 size += vn_sizeof_float(&val->extraPrimitiveOverestimationSize);
793 return size;
794 }
795
796 static inline size_t
vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)797 vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
798 {
799 size_t size = 0;
800
801 size += vn_sizeof_VkStructureType(&val->sType);
802 size += vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(val->pNext);
803 size += vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(val);
804
805 return size;
806 }
807
808 static inline void
vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)809 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
810 {
811 /* no known/supported struct */
812 vn_encode_simple_pointer(enc, NULL);
813 }
814
815 static inline void
vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)816 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
817 {
818 /* skip val->{sType,pNext} */
819 vn_encode_VkFlags(enc, &val->flags);
820 vn_encode_VkConservativeRasterizationModeEXT(enc, &val->conservativeRasterizationMode);
821 vn_encode_float(enc, &val->extraPrimitiveOverestimationSize);
822 }
823
824 static inline void
vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationConservativeStateCreateInfoEXT * val)825 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationConservativeStateCreateInfoEXT *val)
826 {
827 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT);
828 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT });
829 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_pnext(enc, val->pNext);
830 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(enc, val);
831 }
832
833 /* struct VkPipelineRasterizationStateStreamCreateInfoEXT chain */
834
835 static inline size_t
vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(const void * val)836 vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(const void *val)
837 {
838 /* no known/supported struct */
839 return vn_sizeof_simple_pointer(NULL);
840 }
841
842 static inline size_t
vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(const VkPipelineRasterizationStateStreamCreateInfoEXT * val)843 vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
844 {
845 size_t size = 0;
846 /* skip val->{sType,pNext} */
847 size += vn_sizeof_VkFlags(&val->flags);
848 size += vn_sizeof_uint32_t(&val->rasterizationStream);
849 return size;
850 }
851
852 static inline size_t
vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT * val)853 vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
854 {
855 size_t size = 0;
856
857 size += vn_sizeof_VkStructureType(&val->sType);
858 size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(val->pNext);
859 size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self(val);
860
861 return size;
862 }
863
864 static inline void
vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)865 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
866 {
867 /* no known/supported struct */
868 vn_encode_simple_pointer(enc, NULL);
869 }
870
871 static inline void
vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateStreamCreateInfoEXT * val)872 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
873 {
874 /* skip val->{sType,pNext} */
875 vn_encode_VkFlags(enc, &val->flags);
876 vn_encode_uint32_t(enc, &val->rasterizationStream);
877 }
878
879 static inline void
vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateStreamCreateInfoEXT * val)880 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateStreamCreateInfoEXT *val)
881 {
882 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT);
883 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT });
884 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_pnext(enc, val->pNext);
885 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, val);
886 }
887
888 /* struct VkPipelineRasterizationDepthClipStateCreateInfoEXT chain */
889
890 static inline size_t
vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(const void * val)891 vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(const void *val)
892 {
893 /* no known/supported struct */
894 return vn_sizeof_simple_pointer(NULL);
895 }
896
897 static inline size_t
vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)898 vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
899 {
900 size_t size = 0;
901 /* skip val->{sType,pNext} */
902 size += vn_sizeof_VkFlags(&val->flags);
903 size += vn_sizeof_VkBool32(&val->depthClipEnable);
904 return size;
905 }
906
907 static inline size_t
vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)908 vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
909 {
910 size_t size = 0;
911
912 size += vn_sizeof_VkStructureType(&val->sType);
913 size += vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(val->pNext);
914 size += vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(val);
915
916 return size;
917 }
918
919 static inline void
vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)920 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
921 {
922 /* no known/supported struct */
923 vn_encode_simple_pointer(enc, NULL);
924 }
925
926 static inline void
vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)927 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
928 {
929 /* skip val->{sType,pNext} */
930 vn_encode_VkFlags(enc, &val->flags);
931 vn_encode_VkBool32(enc, &val->depthClipEnable);
932 }
933
934 static inline void
vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationDepthClipStateCreateInfoEXT * val)935 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *val)
936 {
937 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT);
938 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT });
939 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_pnext(enc, val->pNext);
940 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(enc, val);
941 }
942
943 /* struct VkPipelineRasterizationLineStateCreateInfoEXT chain */
944
945 static inline size_t
vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(const void * val)946 vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(const void *val)
947 {
948 /* no known/supported struct */
949 return vn_sizeof_simple_pointer(NULL);
950 }
951
952 static inline size_t
vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self(const VkPipelineRasterizationLineStateCreateInfoEXT * val)953 vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self(const VkPipelineRasterizationLineStateCreateInfoEXT *val)
954 {
955 size_t size = 0;
956 /* skip val->{sType,pNext} */
957 size += vn_sizeof_VkLineRasterizationModeEXT(&val->lineRasterizationMode);
958 size += vn_sizeof_VkBool32(&val->stippledLineEnable);
959 size += vn_sizeof_uint32_t(&val->lineStippleFactor);
960 size += vn_sizeof_uint16_t(&val->lineStipplePattern);
961 return size;
962 }
963
964 static inline size_t
vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT * val)965 vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT *val)
966 {
967 size_t size = 0;
968
969 size += vn_sizeof_VkStructureType(&val->sType);
970 size += vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(val->pNext);
971 size += vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self(val);
972
973 return size;
974 }
975
976 static inline void
vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)977 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
978 {
979 /* no known/supported struct */
980 vn_encode_simple_pointer(enc, NULL);
981 }
982
983 static inline void
vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationLineStateCreateInfoEXT * val)984 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationLineStateCreateInfoEXT *val)
985 {
986 /* skip val->{sType,pNext} */
987 vn_encode_VkLineRasterizationModeEXT(enc, &val->lineRasterizationMode);
988 vn_encode_VkBool32(enc, &val->stippledLineEnable);
989 vn_encode_uint32_t(enc, &val->lineStippleFactor);
990 vn_encode_uint16_t(enc, &val->lineStipplePattern);
991 }
992
993 static inline void
vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationLineStateCreateInfoEXT * val)994 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationLineStateCreateInfoEXT *val)
995 {
996 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT);
997 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT });
998 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_pnext(enc, val->pNext);
999 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(enc, val);
1000 }
1001
1002 /* struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT chain */
1003
1004 static inline size_t
vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(const void * val)1005 vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(const void *val)
1006 {
1007 /* no known/supported struct */
1008 return vn_sizeof_simple_pointer(NULL);
1009 }
1010
1011 static inline size_t
vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1012 vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1013 {
1014 size_t size = 0;
1015 /* skip val->{sType,pNext} */
1016 size += vn_sizeof_VkProvokingVertexModeEXT(&val->provokingVertexMode);
1017 return size;
1018 }
1019
1020 static inline size_t
vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1021 vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1022 {
1023 size_t size = 0;
1024
1025 size += vn_sizeof_VkStructureType(&val->sType);
1026 size += vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(val->pNext);
1027 size += vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(val);
1028
1029 return size;
1030 }
1031
1032 static inline void
vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)1033 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
1034 {
1035 /* no known/supported struct */
1036 vn_encode_simple_pointer(enc, NULL);
1037 }
1038
1039 static inline void
vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1040 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1041 {
1042 /* skip val->{sType,pNext} */
1043 vn_encode_VkProvokingVertexModeEXT(enc, &val->provokingVertexMode);
1044 }
1045
1046 static inline void
vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(struct vn_cs_encoder * enc,const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT * val)1047 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(struct vn_cs_encoder *enc, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *val)
1048 {
1049 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT);
1050 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT });
1051 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_pnext(enc, val->pNext);
1052 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(enc, val);
1053 }
1054
1055 /* struct VkPipelineRasterizationStateCreateInfo chain */
1056
1057 static inline size_t
vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(const void * val)1058 vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(const void *val)
1059 {
1060 const VkBaseInStructure *pnext = val;
1061 size_t size = 0;
1062
1063 while (pnext) {
1064 switch ((int32_t)pnext->sType) {
1065 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
1066 if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
1067 break;
1068 size += vn_sizeof_simple_pointer(pnext);
1069 size += vn_sizeof_VkStructureType(&pnext->sType);
1070 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1071 size += vn_sizeof_VkPipelineRasterizationConservativeStateCreateInfoEXT_self((const VkPipelineRasterizationConservativeStateCreateInfoEXT *)pnext);
1072 return size;
1073 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
1074 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
1075 break;
1076 size += vn_sizeof_simple_pointer(pnext);
1077 size += vn_sizeof_VkStructureType(&pnext->sType);
1078 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1079 size += vn_sizeof_VkPipelineRasterizationStateStreamCreateInfoEXT_self((const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
1080 return size;
1081 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
1082 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
1083 break;
1084 size += vn_sizeof_simple_pointer(pnext);
1085 size += vn_sizeof_VkStructureType(&pnext->sType);
1086 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1087 size += vn_sizeof_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self((const VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pnext);
1088 return size;
1089 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
1090 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
1091 break;
1092 size += vn_sizeof_simple_pointer(pnext);
1093 size += vn_sizeof_VkStructureType(&pnext->sType);
1094 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1095 size += vn_sizeof_VkPipelineRasterizationLineStateCreateInfoEXT_self((const VkPipelineRasterizationLineStateCreateInfoEXT *)pnext);
1096 return size;
1097 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
1098 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
1099 break;
1100 size += vn_sizeof_simple_pointer(pnext);
1101 size += vn_sizeof_VkStructureType(&pnext->sType);
1102 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(pnext->pNext);
1103 size += vn_sizeof_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self((const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)pnext);
1104 return size;
1105 default:
1106 /* ignore unknown/unsupported struct */
1107 break;
1108 }
1109 pnext = pnext->pNext;
1110 }
1111
1112 return vn_sizeof_simple_pointer(NULL);
1113 }
1114
1115 static inline size_t
vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(const VkPipelineRasterizationStateCreateInfo * val)1116 vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(const VkPipelineRasterizationStateCreateInfo *val)
1117 {
1118 size_t size = 0;
1119 /* skip val->{sType,pNext} */
1120 size += vn_sizeof_VkFlags(&val->flags);
1121 size += vn_sizeof_VkBool32(&val->depthClampEnable);
1122 size += vn_sizeof_VkBool32(&val->rasterizerDiscardEnable);
1123 size += vn_sizeof_VkPolygonMode(&val->polygonMode);
1124 size += vn_sizeof_VkFlags(&val->cullMode);
1125 size += vn_sizeof_VkFrontFace(&val->frontFace);
1126 size += vn_sizeof_VkBool32(&val->depthBiasEnable);
1127 size += vn_sizeof_float(&val->depthBiasConstantFactor);
1128 size += vn_sizeof_float(&val->depthBiasClamp);
1129 size += vn_sizeof_float(&val->depthBiasSlopeFactor);
1130 size += vn_sizeof_float(&val->lineWidth);
1131 return size;
1132 }
1133
1134 static inline size_t
vn_sizeof_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo * val)1135 vn_sizeof_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo *val)
1136 {
1137 size_t size = 0;
1138
1139 size += vn_sizeof_VkStructureType(&val->sType);
1140 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_pnext(val->pNext);
1141 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo_self(val);
1142
1143 return size;
1144 }
1145
1146 static inline void
vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1147 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1148 {
1149 const VkBaseInStructure *pnext = val;
1150
1151 while (pnext) {
1152 switch ((int32_t)pnext->sType) {
1153 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
1154 if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
1155 break;
1156 vn_encode_simple_pointer(enc, pnext);
1157 vn_encode_VkStructureType(enc, &pnext->sType);
1158 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1159 vn_encode_VkPipelineRasterizationConservativeStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationConservativeStateCreateInfoEXT *)pnext);
1160 return;
1161 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
1162 if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
1163 break;
1164 vn_encode_simple_pointer(enc, pnext);
1165 vn_encode_VkStructureType(enc, &pnext->sType);
1166 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1167 vn_encode_VkPipelineRasterizationStateStreamCreateInfoEXT_self(enc, (const VkPipelineRasterizationStateStreamCreateInfoEXT *)pnext);
1168 return;
1169 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
1170 if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
1171 break;
1172 vn_encode_simple_pointer(enc, pnext);
1173 vn_encode_VkStructureType(enc, &pnext->sType);
1174 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1175 vn_encode_VkPipelineRasterizationDepthClipStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pnext);
1176 return;
1177 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
1178 if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
1179 break;
1180 vn_encode_simple_pointer(enc, pnext);
1181 vn_encode_VkStructureType(enc, &pnext->sType);
1182 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1183 vn_encode_VkPipelineRasterizationLineStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationLineStateCreateInfoEXT *)pnext);
1184 return;
1185 case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
1186 if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
1187 break;
1188 vn_encode_simple_pointer(enc, pnext);
1189 vn_encode_VkStructureType(enc, &pnext->sType);
1190 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, pnext->pNext);
1191 vn_encode_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT_self(enc, (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)pnext);
1192 return;
1193 default:
1194 /* ignore unknown/unsupported struct */
1195 break;
1196 }
1197 pnext = pnext->pNext;
1198 }
1199
1200 vn_encode_simple_pointer(enc, NULL);
1201 }
1202
1203 static inline void
vn_encode_VkPipelineRasterizationStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateCreateInfo * val)1204 vn_encode_VkPipelineRasterizationStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
1205 {
1206 /* skip val->{sType,pNext} */
1207 vn_encode_VkFlags(enc, &val->flags);
1208 vn_encode_VkBool32(enc, &val->depthClampEnable);
1209 vn_encode_VkBool32(enc, &val->rasterizerDiscardEnable);
1210 vn_encode_VkPolygonMode(enc, &val->polygonMode);
1211 vn_encode_VkFlags(enc, &val->cullMode);
1212 vn_encode_VkFrontFace(enc, &val->frontFace);
1213 vn_encode_VkBool32(enc, &val->depthBiasEnable);
1214 vn_encode_float(enc, &val->depthBiasConstantFactor);
1215 vn_encode_float(enc, &val->depthBiasClamp);
1216 vn_encode_float(enc, &val->depthBiasSlopeFactor);
1217 vn_encode_float(enc, &val->lineWidth);
1218 }
1219
1220 static inline void
vn_encode_VkPipelineRasterizationStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineRasterizationStateCreateInfo * val)1221 vn_encode_VkPipelineRasterizationStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRasterizationStateCreateInfo *val)
1222 {
1223 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO);
1224 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO });
1225 vn_encode_VkPipelineRasterizationStateCreateInfo_pnext(enc, val->pNext);
1226 vn_encode_VkPipelineRasterizationStateCreateInfo_self(enc, val);
1227 }
1228
1229 /* struct VkPipelineMultisampleStateCreateInfo chain */
1230
1231 static inline size_t
vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(const void * val)1232 vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(const void *val)
1233 {
1234 /* no known/supported struct */
1235 return vn_sizeof_simple_pointer(NULL);
1236 }
1237
1238 static inline size_t
vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(const VkPipelineMultisampleStateCreateInfo * val)1239 vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(const VkPipelineMultisampleStateCreateInfo *val)
1240 {
1241 size_t size = 0;
1242 /* skip val->{sType,pNext} */
1243 size += vn_sizeof_VkFlags(&val->flags);
1244 size += vn_sizeof_VkSampleCountFlagBits(&val->rasterizationSamples);
1245 size += vn_sizeof_VkBool32(&val->sampleShadingEnable);
1246 size += vn_sizeof_float(&val->minSampleShading);
1247 if (val->pSampleMask) {
1248 size += vn_sizeof_array_size((val->rasterizationSamples + 31) / 32);
1249 size += vn_sizeof_VkSampleMask_array(val->pSampleMask, (val->rasterizationSamples + 31) / 32);
1250 } else {
1251 size += vn_sizeof_array_size(0);
1252 }
1253 size += vn_sizeof_VkBool32(&val->alphaToCoverageEnable);
1254 size += vn_sizeof_VkBool32(&val->alphaToOneEnable);
1255 return size;
1256 }
1257
1258 static inline size_t
vn_sizeof_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo * val)1259 vn_sizeof_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo *val)
1260 {
1261 size_t size = 0;
1262
1263 size += vn_sizeof_VkStructureType(&val->sType);
1264 size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_pnext(val->pNext);
1265 size += vn_sizeof_VkPipelineMultisampleStateCreateInfo_self(val);
1266
1267 return size;
1268 }
1269
1270 static inline void
vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1271 vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1272 {
1273 /* no known/supported struct */
1274 vn_encode_simple_pointer(enc, NULL);
1275 }
1276
1277 static inline void
vn_encode_VkPipelineMultisampleStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineMultisampleStateCreateInfo * val)1278 vn_encode_VkPipelineMultisampleStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
1279 {
1280 /* skip val->{sType,pNext} */
1281 vn_encode_VkFlags(enc, &val->flags);
1282 vn_encode_VkSampleCountFlagBits(enc, &val->rasterizationSamples);
1283 vn_encode_VkBool32(enc, &val->sampleShadingEnable);
1284 vn_encode_float(enc, &val->minSampleShading);
1285 if (val->pSampleMask) {
1286 vn_encode_array_size(enc, (val->rasterizationSamples + 31) / 32);
1287 vn_encode_VkSampleMask_array(enc, val->pSampleMask, (val->rasterizationSamples + 31) / 32);
1288 } else {
1289 vn_encode_array_size(enc, 0);
1290 }
1291 vn_encode_VkBool32(enc, &val->alphaToCoverageEnable);
1292 vn_encode_VkBool32(enc, &val->alphaToOneEnable);
1293 }
1294
1295 static inline void
vn_encode_VkPipelineMultisampleStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineMultisampleStateCreateInfo * val)1296 vn_encode_VkPipelineMultisampleStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineMultisampleStateCreateInfo *val)
1297 {
1298 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO);
1299 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO });
1300 vn_encode_VkPipelineMultisampleStateCreateInfo_pnext(enc, val->pNext);
1301 vn_encode_VkPipelineMultisampleStateCreateInfo_self(enc, val);
1302 }
1303
1304 /* struct VkStencilOpState */
1305
1306 static inline size_t
vn_sizeof_VkStencilOpState(const VkStencilOpState * val)1307 vn_sizeof_VkStencilOpState(const VkStencilOpState *val)
1308 {
1309 size_t size = 0;
1310 size += vn_sizeof_VkStencilOp(&val->failOp);
1311 size += vn_sizeof_VkStencilOp(&val->passOp);
1312 size += vn_sizeof_VkStencilOp(&val->depthFailOp);
1313 size += vn_sizeof_VkCompareOp(&val->compareOp);
1314 size += vn_sizeof_uint32_t(&val->compareMask);
1315 size += vn_sizeof_uint32_t(&val->writeMask);
1316 size += vn_sizeof_uint32_t(&val->reference);
1317 return size;
1318 }
1319
1320 static inline void
vn_encode_VkStencilOpState(struct vn_cs_encoder * enc,const VkStencilOpState * val)1321 vn_encode_VkStencilOpState(struct vn_cs_encoder *enc, const VkStencilOpState *val)
1322 {
1323 vn_encode_VkStencilOp(enc, &val->failOp);
1324 vn_encode_VkStencilOp(enc, &val->passOp);
1325 vn_encode_VkStencilOp(enc, &val->depthFailOp);
1326 vn_encode_VkCompareOp(enc, &val->compareOp);
1327 vn_encode_uint32_t(enc, &val->compareMask);
1328 vn_encode_uint32_t(enc, &val->writeMask);
1329 vn_encode_uint32_t(enc, &val->reference);
1330 }
1331
1332 /* struct VkPipelineDepthStencilStateCreateInfo chain */
1333
1334 static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(const void * val)1335 vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(const void *val)
1336 {
1337 /* no known/supported struct */
1338 return vn_sizeof_simple_pointer(NULL);
1339 }
1340
1341 static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(const VkPipelineDepthStencilStateCreateInfo * val)1342 vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(const VkPipelineDepthStencilStateCreateInfo *val)
1343 {
1344 size_t size = 0;
1345 /* skip val->{sType,pNext} */
1346 size += vn_sizeof_VkFlags(&val->flags);
1347 size += vn_sizeof_VkBool32(&val->depthTestEnable);
1348 size += vn_sizeof_VkBool32(&val->depthWriteEnable);
1349 size += vn_sizeof_VkCompareOp(&val->depthCompareOp);
1350 size += vn_sizeof_VkBool32(&val->depthBoundsTestEnable);
1351 size += vn_sizeof_VkBool32(&val->stencilTestEnable);
1352 size += vn_sizeof_VkStencilOpState(&val->front);
1353 size += vn_sizeof_VkStencilOpState(&val->back);
1354 size += vn_sizeof_float(&val->minDepthBounds);
1355 size += vn_sizeof_float(&val->maxDepthBounds);
1356 return size;
1357 }
1358
1359 static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo * val)1360 vn_sizeof_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo *val)
1361 {
1362 size_t size = 0;
1363
1364 size += vn_sizeof_VkStructureType(&val->sType);
1365 size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_pnext(val->pNext);
1366 size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo_self(val);
1367
1368 return size;
1369 }
1370
1371 static inline void
vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1372 vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1373 {
1374 /* no known/supported struct */
1375 vn_encode_simple_pointer(enc, NULL);
1376 }
1377
1378 static inline void
vn_encode_VkPipelineDepthStencilStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineDepthStencilStateCreateInfo * val)1379 vn_encode_VkPipelineDepthStencilStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
1380 {
1381 /* skip val->{sType,pNext} */
1382 vn_encode_VkFlags(enc, &val->flags);
1383 vn_encode_VkBool32(enc, &val->depthTestEnable);
1384 vn_encode_VkBool32(enc, &val->depthWriteEnable);
1385 vn_encode_VkCompareOp(enc, &val->depthCompareOp);
1386 vn_encode_VkBool32(enc, &val->depthBoundsTestEnable);
1387 vn_encode_VkBool32(enc, &val->stencilTestEnable);
1388 vn_encode_VkStencilOpState(enc, &val->front);
1389 vn_encode_VkStencilOpState(enc, &val->back);
1390 vn_encode_float(enc, &val->minDepthBounds);
1391 vn_encode_float(enc, &val->maxDepthBounds);
1392 }
1393
1394 static inline void
vn_encode_VkPipelineDepthStencilStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineDepthStencilStateCreateInfo * val)1395 vn_encode_VkPipelineDepthStencilStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateInfo *val)
1396 {
1397 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO);
1398 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO });
1399 vn_encode_VkPipelineDepthStencilStateCreateInfo_pnext(enc, val->pNext);
1400 vn_encode_VkPipelineDepthStencilStateCreateInfo_self(enc, val);
1401 }
1402
1403 /* struct VkPipelineColorBlendAttachmentState */
1404
1405 static inline size_t
vn_sizeof_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState * val)1406 vn_sizeof_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState *val)
1407 {
1408 size_t size = 0;
1409 size += vn_sizeof_VkBool32(&val->blendEnable);
1410 size += vn_sizeof_VkBlendFactor(&val->srcColorBlendFactor);
1411 size += vn_sizeof_VkBlendFactor(&val->dstColorBlendFactor);
1412 size += vn_sizeof_VkBlendOp(&val->colorBlendOp);
1413 size += vn_sizeof_VkBlendFactor(&val->srcAlphaBlendFactor);
1414 size += vn_sizeof_VkBlendFactor(&val->dstAlphaBlendFactor);
1415 size += vn_sizeof_VkBlendOp(&val->alphaBlendOp);
1416 size += vn_sizeof_VkFlags(&val->colorWriteMask);
1417 return size;
1418 }
1419
1420 static inline void
vn_encode_VkPipelineColorBlendAttachmentState(struct vn_cs_encoder * enc,const VkPipelineColorBlendAttachmentState * val)1421 vn_encode_VkPipelineColorBlendAttachmentState(struct vn_cs_encoder *enc, const VkPipelineColorBlendAttachmentState *val)
1422 {
1423 vn_encode_VkBool32(enc, &val->blendEnable);
1424 vn_encode_VkBlendFactor(enc, &val->srcColorBlendFactor);
1425 vn_encode_VkBlendFactor(enc, &val->dstColorBlendFactor);
1426 vn_encode_VkBlendOp(enc, &val->colorBlendOp);
1427 vn_encode_VkBlendFactor(enc, &val->srcAlphaBlendFactor);
1428 vn_encode_VkBlendFactor(enc, &val->dstAlphaBlendFactor);
1429 vn_encode_VkBlendOp(enc, &val->alphaBlendOp);
1430 vn_encode_VkFlags(enc, &val->colorWriteMask);
1431 }
1432
1433 /* struct VkPipelineColorBlendStateCreateInfo chain */
1434
1435 static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(const void * val)1436 vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(const void *val)
1437 {
1438 /* no known/supported struct */
1439 return vn_sizeof_simple_pointer(NULL);
1440 }
1441
1442 static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(const VkPipelineColorBlendStateCreateInfo * val)1443 vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(const VkPipelineColorBlendStateCreateInfo *val)
1444 {
1445 size_t size = 0;
1446 /* skip val->{sType,pNext} */
1447 size += vn_sizeof_VkFlags(&val->flags);
1448 size += vn_sizeof_VkBool32(&val->logicOpEnable);
1449 size += vn_sizeof_VkLogicOp(&val->logicOp);
1450 size += vn_sizeof_uint32_t(&val->attachmentCount);
1451 if (val->pAttachments) {
1452 size += vn_sizeof_array_size(val->attachmentCount);
1453 for (uint32_t i = 0; i < val->attachmentCount; i++)
1454 size += vn_sizeof_VkPipelineColorBlendAttachmentState(&val->pAttachments[i]);
1455 } else {
1456 size += vn_sizeof_array_size(0);
1457 }
1458 size += vn_sizeof_array_size(4);
1459 size += vn_sizeof_float_array(val->blendConstants, 4);
1460 return size;
1461 }
1462
1463 static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo * val)1464 vn_sizeof_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo *val)
1465 {
1466 size_t size = 0;
1467
1468 size += vn_sizeof_VkStructureType(&val->sType);
1469 size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_pnext(val->pNext);
1470 size += vn_sizeof_VkPipelineColorBlendStateCreateInfo_self(val);
1471
1472 return size;
1473 }
1474
1475 static inline void
vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1476 vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1477 {
1478 /* no known/supported struct */
1479 vn_encode_simple_pointer(enc, NULL);
1480 }
1481
1482 static inline void
vn_encode_VkPipelineColorBlendStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineColorBlendStateCreateInfo * val)1483 vn_encode_VkPipelineColorBlendStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
1484 {
1485 /* skip val->{sType,pNext} */
1486 vn_encode_VkFlags(enc, &val->flags);
1487 vn_encode_VkBool32(enc, &val->logicOpEnable);
1488 vn_encode_VkLogicOp(enc, &val->logicOp);
1489 vn_encode_uint32_t(enc, &val->attachmentCount);
1490 if (val->pAttachments) {
1491 vn_encode_array_size(enc, val->attachmentCount);
1492 for (uint32_t i = 0; i < val->attachmentCount; i++)
1493 vn_encode_VkPipelineColorBlendAttachmentState(enc, &val->pAttachments[i]);
1494 } else {
1495 vn_encode_array_size(enc, 0);
1496 }
1497 vn_encode_array_size(enc, 4);
1498 vn_encode_float_array(enc, val->blendConstants, 4);
1499 }
1500
1501 static inline void
vn_encode_VkPipelineColorBlendStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineColorBlendStateCreateInfo * val)1502 vn_encode_VkPipelineColorBlendStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateInfo *val)
1503 {
1504 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO);
1505 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO });
1506 vn_encode_VkPipelineColorBlendStateCreateInfo_pnext(enc, val->pNext);
1507 vn_encode_VkPipelineColorBlendStateCreateInfo_self(enc, val);
1508 }
1509
1510 /* struct VkPipelineDynamicStateCreateInfo chain */
1511
1512 static inline size_t
vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(const void * val)1513 vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(const void *val)
1514 {
1515 /* no known/supported struct */
1516 return vn_sizeof_simple_pointer(NULL);
1517 }
1518
1519 static inline size_t
vn_sizeof_VkPipelineDynamicStateCreateInfo_self(const VkPipelineDynamicStateCreateInfo * val)1520 vn_sizeof_VkPipelineDynamicStateCreateInfo_self(const VkPipelineDynamicStateCreateInfo *val)
1521 {
1522 size_t size = 0;
1523 /* skip val->{sType,pNext} */
1524 size += vn_sizeof_VkFlags(&val->flags);
1525 size += vn_sizeof_uint32_t(&val->dynamicStateCount);
1526 if (val->pDynamicStates) {
1527 size += vn_sizeof_array_size(val->dynamicStateCount);
1528 size += vn_sizeof_VkDynamicState_array(val->pDynamicStates, val->dynamicStateCount);
1529 } else {
1530 size += vn_sizeof_array_size(0);
1531 }
1532 return size;
1533 }
1534
1535 static inline size_t
vn_sizeof_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo * val)1536 vn_sizeof_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo *val)
1537 {
1538 size_t size = 0;
1539
1540 size += vn_sizeof_VkStructureType(&val->sType);
1541 size += vn_sizeof_VkPipelineDynamicStateCreateInfo_pnext(val->pNext);
1542 size += vn_sizeof_VkPipelineDynamicStateCreateInfo_self(val);
1543
1544 return size;
1545 }
1546
1547 static inline void
vn_encode_VkPipelineDynamicStateCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1548 vn_encode_VkPipelineDynamicStateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1549 {
1550 /* no known/supported struct */
1551 vn_encode_simple_pointer(enc, NULL);
1552 }
1553
1554 static inline void
vn_encode_VkPipelineDynamicStateCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineDynamicStateCreateInfo * val)1555 vn_encode_VkPipelineDynamicStateCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
1556 {
1557 /* skip val->{sType,pNext} */
1558 vn_encode_VkFlags(enc, &val->flags);
1559 vn_encode_uint32_t(enc, &val->dynamicStateCount);
1560 if (val->pDynamicStates) {
1561 vn_encode_array_size(enc, val->dynamicStateCount);
1562 vn_encode_VkDynamicState_array(enc, val->pDynamicStates, val->dynamicStateCount);
1563 } else {
1564 vn_encode_array_size(enc, 0);
1565 }
1566 }
1567
1568 static inline void
vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder * enc,const VkPipelineDynamicStateCreateInfo * val)1569 vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPipelineDynamicStateCreateInfo *val)
1570 {
1571 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO);
1572 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO });
1573 vn_encode_VkPipelineDynamicStateCreateInfo_pnext(enc, val->pNext);
1574 vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val);
1575 }
1576
1577 /* struct VkPipelineCreationFeedback */
1578
1579 static inline size_t
vn_sizeof_VkPipelineCreationFeedback(const VkPipelineCreationFeedback * val)1580 vn_sizeof_VkPipelineCreationFeedback(const VkPipelineCreationFeedback *val)
1581 {
1582 size_t size = 0;
1583 size += vn_sizeof_VkFlags(&val->flags);
1584 size += vn_sizeof_uint64_t(&val->duration);
1585 return size;
1586 }
1587
1588 static inline void
vn_encode_VkPipelineCreationFeedback(struct vn_cs_encoder * enc,const VkPipelineCreationFeedback * val)1589 vn_encode_VkPipelineCreationFeedback(struct vn_cs_encoder *enc, const VkPipelineCreationFeedback *val)
1590 {
1591 vn_encode_VkFlags(enc, &val->flags);
1592 vn_encode_uint64_t(enc, &val->duration);
1593 }
1594
1595 /* struct VkPipelineCreationFeedbackCreateInfo chain */
1596
1597 static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(const void * val)1598 vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(const void *val)
1599 {
1600 /* no known/supported struct */
1601 return vn_sizeof_simple_pointer(NULL);
1602 }
1603
1604 static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(const VkPipelineCreationFeedbackCreateInfo * val)1605 vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(const VkPipelineCreationFeedbackCreateInfo *val)
1606 {
1607 size_t size = 0;
1608 /* skip val->{sType,pNext} */
1609 size += vn_sizeof_simple_pointer(val->pPipelineCreationFeedback);
1610 if (val->pPipelineCreationFeedback)
1611 size += vn_sizeof_VkPipelineCreationFeedback(val->pPipelineCreationFeedback);
1612 size += vn_sizeof_uint32_t(&val->pipelineStageCreationFeedbackCount);
1613 if (val->pPipelineStageCreationFeedbacks) {
1614 size += vn_sizeof_array_size(val->pipelineStageCreationFeedbackCount);
1615 for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
1616 size += vn_sizeof_VkPipelineCreationFeedback(&val->pPipelineStageCreationFeedbacks[i]);
1617 } else {
1618 size += vn_sizeof_array_size(0);
1619 }
1620 return size;
1621 }
1622
1623 static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo * val)1624 vn_sizeof_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo *val)
1625 {
1626 size_t size = 0;
1627
1628 size += vn_sizeof_VkStructureType(&val->sType);
1629 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(val->pNext);
1630 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(val);
1631
1632 return size;
1633 }
1634
1635 static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1636 vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1637 {
1638 /* no known/supported struct */
1639 vn_encode_simple_pointer(enc, NULL);
1640 }
1641
1642 static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineCreationFeedbackCreateInfo * val)1643 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val)
1644 {
1645 /* skip val->{sType,pNext} */
1646 if (vn_encode_simple_pointer(enc, val->pPipelineCreationFeedback))
1647 vn_encode_VkPipelineCreationFeedback(enc, val->pPipelineCreationFeedback);
1648 vn_encode_uint32_t(enc, &val->pipelineStageCreationFeedbackCount);
1649 if (val->pPipelineStageCreationFeedbacks) {
1650 vn_encode_array_size(enc, val->pipelineStageCreationFeedbackCount);
1651 for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
1652 vn_encode_VkPipelineCreationFeedback(enc, &val->pPipelineStageCreationFeedbacks[i]);
1653 } else {
1654 vn_encode_array_size(enc, 0);
1655 }
1656 }
1657
1658 static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo(struct vn_cs_encoder * enc,const VkPipelineCreationFeedbackCreateInfo * val)1659 vn_encode_VkPipelineCreationFeedbackCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val)
1660 {
1661 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
1662 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO });
1663 vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(enc, val->pNext);
1664 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, val);
1665 }
1666
1667 /* struct VkPipelineRenderingCreateInfo chain */
1668
1669 static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo_pnext(const void * val)1670 vn_sizeof_VkPipelineRenderingCreateInfo_pnext(const void *val)
1671 {
1672 /* no known/supported struct */
1673 return vn_sizeof_simple_pointer(NULL);
1674 }
1675
1676 static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo_self(const VkPipelineRenderingCreateInfo * val)1677 vn_sizeof_VkPipelineRenderingCreateInfo_self(const VkPipelineRenderingCreateInfo *val)
1678 {
1679 size_t size = 0;
1680 /* skip val->{sType,pNext} */
1681 size += vn_sizeof_uint32_t(&val->viewMask);
1682 size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
1683 if (val->pColorAttachmentFormats) {
1684 size += vn_sizeof_array_size(val->colorAttachmentCount);
1685 size += vn_sizeof_VkFormat_array(val->pColorAttachmentFormats, val->colorAttachmentCount);
1686 } else {
1687 size += vn_sizeof_array_size(0);
1688 }
1689 size += vn_sizeof_VkFormat(&val->depthAttachmentFormat);
1690 size += vn_sizeof_VkFormat(&val->stencilAttachmentFormat);
1691 return size;
1692 }
1693
1694 static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo * val)1695 vn_sizeof_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo *val)
1696 {
1697 size_t size = 0;
1698
1699 size += vn_sizeof_VkStructureType(&val->sType);
1700 size += vn_sizeof_VkPipelineRenderingCreateInfo_pnext(val->pNext);
1701 size += vn_sizeof_VkPipelineRenderingCreateInfo_self(val);
1702
1703 return size;
1704 }
1705
1706 static inline void
vn_encode_VkPipelineRenderingCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1707 vn_encode_VkPipelineRenderingCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1708 {
1709 /* no known/supported struct */
1710 vn_encode_simple_pointer(enc, NULL);
1711 }
1712
1713 static inline void
vn_encode_VkPipelineRenderingCreateInfo_self(struct vn_cs_encoder * enc,const VkPipelineRenderingCreateInfo * val)1714 vn_encode_VkPipelineRenderingCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val)
1715 {
1716 /* skip val->{sType,pNext} */
1717 vn_encode_uint32_t(enc, &val->viewMask);
1718 vn_encode_uint32_t(enc, &val->colorAttachmentCount);
1719 if (val->pColorAttachmentFormats) {
1720 vn_encode_array_size(enc, val->colorAttachmentCount);
1721 vn_encode_VkFormat_array(enc, val->pColorAttachmentFormats, val->colorAttachmentCount);
1722 } else {
1723 vn_encode_array_size(enc, 0);
1724 }
1725 vn_encode_VkFormat(enc, &val->depthAttachmentFormat);
1726 vn_encode_VkFormat(enc, &val->stencilAttachmentFormat);
1727 }
1728
1729 static inline void
vn_encode_VkPipelineRenderingCreateInfo(struct vn_cs_encoder * enc,const VkPipelineRenderingCreateInfo * val)1730 vn_encode_VkPipelineRenderingCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val)
1731 {
1732 assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
1733 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO });
1734 vn_encode_VkPipelineRenderingCreateInfo_pnext(enc, val->pNext);
1735 vn_encode_VkPipelineRenderingCreateInfo_self(enc, val);
1736 }
1737
1738 /* struct VkGraphicsPipelineCreateInfo chain */
1739
1740 static inline size_t
vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void * val)1741 vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val)
1742 {
1743 const VkBaseInStructure *pnext = val;
1744 size_t size = 0;
1745
1746 while (pnext) {
1747 switch ((int32_t)pnext->sType) {
1748 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
1749 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
1750 break;
1751 size += vn_sizeof_simple_pointer(pnext);
1752 size += vn_sizeof_VkStructureType(&pnext->sType);
1753 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
1754 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext);
1755 return size;
1756 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
1757 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
1758 break;
1759 size += vn_sizeof_simple_pointer(pnext);
1760 size += vn_sizeof_VkStructureType(&pnext->sType);
1761 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
1762 size += vn_sizeof_VkPipelineRenderingCreateInfo_self((const VkPipelineRenderingCreateInfo *)pnext);
1763 return size;
1764 default:
1765 /* ignore unknown/unsupported struct */
1766 break;
1767 }
1768 pnext = pnext->pNext;
1769 }
1770
1771 return vn_sizeof_simple_pointer(NULL);
1772 }
1773
1774 static inline size_t
vn_sizeof_VkGraphicsPipelineCreateInfo_self(const VkGraphicsPipelineCreateInfo * val)1775 vn_sizeof_VkGraphicsPipelineCreateInfo_self(const VkGraphicsPipelineCreateInfo *val)
1776 {
1777 size_t size = 0;
1778 /* skip val->{sType,pNext} */
1779 size += vn_sizeof_VkFlags(&val->flags);
1780 size += vn_sizeof_uint32_t(&val->stageCount);
1781 if (val->pStages) {
1782 size += vn_sizeof_array_size(val->stageCount);
1783 for (uint32_t i = 0; i < val->stageCount; i++)
1784 size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->pStages[i]);
1785 } else {
1786 size += vn_sizeof_array_size(0);
1787 }
1788 size += vn_sizeof_simple_pointer(val->pVertexInputState);
1789 if (val->pVertexInputState)
1790 size += vn_sizeof_VkPipelineVertexInputStateCreateInfo(val->pVertexInputState);
1791 size += vn_sizeof_simple_pointer(val->pInputAssemblyState);
1792 if (val->pInputAssemblyState)
1793 size += vn_sizeof_VkPipelineInputAssemblyStateCreateInfo(val->pInputAssemblyState);
1794 size += vn_sizeof_simple_pointer(val->pTessellationState);
1795 if (val->pTessellationState)
1796 size += vn_sizeof_VkPipelineTessellationStateCreateInfo(val->pTessellationState);
1797 size += vn_sizeof_simple_pointer(val->pViewportState);
1798 if (val->pViewportState)
1799 size += vn_sizeof_VkPipelineViewportStateCreateInfo(val->pViewportState);
1800 size += vn_sizeof_simple_pointer(val->pRasterizationState);
1801 if (val->pRasterizationState)
1802 size += vn_sizeof_VkPipelineRasterizationStateCreateInfo(val->pRasterizationState);
1803 size += vn_sizeof_simple_pointer(val->pMultisampleState);
1804 if (val->pMultisampleState)
1805 size += vn_sizeof_VkPipelineMultisampleStateCreateInfo(val->pMultisampleState);
1806 size += vn_sizeof_simple_pointer(val->pDepthStencilState);
1807 if (val->pDepthStencilState)
1808 size += vn_sizeof_VkPipelineDepthStencilStateCreateInfo(val->pDepthStencilState);
1809 size += vn_sizeof_simple_pointer(val->pColorBlendState);
1810 if (val->pColorBlendState)
1811 size += vn_sizeof_VkPipelineColorBlendStateCreateInfo(val->pColorBlendState);
1812 size += vn_sizeof_simple_pointer(val->pDynamicState);
1813 if (val->pDynamicState)
1814 size += vn_sizeof_VkPipelineDynamicStateCreateInfo(val->pDynamicState);
1815 size += vn_sizeof_VkPipelineLayout(&val->layout);
1816 size += vn_sizeof_VkRenderPass(&val->renderPass);
1817 size += vn_sizeof_uint32_t(&val->subpass);
1818 size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
1819 size += vn_sizeof_int32_t(&val->basePipelineIndex);
1820 return size;
1821 }
1822
1823 static inline size_t
vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo * val)1824 vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *val)
1825 {
1826 size_t size = 0;
1827
1828 size += vn_sizeof_VkStructureType(&val->sType);
1829 size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(val->pNext);
1830 size += vn_sizeof_VkGraphicsPipelineCreateInfo_self(val);
1831
1832 return size;
1833 }
1834
1835 static inline void
vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1836 vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1837 {
1838 const VkBaseInStructure *pnext = val;
1839
1840 while (pnext) {
1841 switch ((int32_t)pnext->sType) {
1842 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
1843 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
1844 break;
1845 vn_encode_simple_pointer(enc, pnext);
1846 vn_encode_VkStructureType(enc, &pnext->sType);
1847 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
1848 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext);
1849 return;
1850 case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
1851 if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
1852 break;
1853 vn_encode_simple_pointer(enc, pnext);
1854 vn_encode_VkStructureType(enc, &pnext->sType);
1855 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
1856 vn_encode_VkPipelineRenderingCreateInfo_self(enc, (const VkPipelineRenderingCreateInfo *)pnext);
1857 return;
1858 default:
1859 /* ignore unknown/unsupported struct */
1860 break;
1861 }
1862 pnext = pnext->pNext;
1863 }
1864
1865 vn_encode_simple_pointer(enc, NULL);
1866 }
1867
1868 static inline void
vn_encode_VkGraphicsPipelineCreateInfo_self(struct vn_cs_encoder * enc,const VkGraphicsPipelineCreateInfo * val)1869 vn_encode_VkGraphicsPipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
1870 {
1871 /* skip val->{sType,pNext} */
1872 vn_encode_VkFlags(enc, &val->flags);
1873 vn_encode_uint32_t(enc, &val->stageCount);
1874 if (val->pStages) {
1875 vn_encode_array_size(enc, val->stageCount);
1876 for (uint32_t i = 0; i < val->stageCount; i++)
1877 vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->pStages[i]);
1878 } else {
1879 vn_encode_array_size(enc, 0);
1880 }
1881 if (vn_encode_simple_pointer(enc, val->pVertexInputState))
1882 vn_encode_VkPipelineVertexInputStateCreateInfo(enc, val->pVertexInputState);
1883 if (vn_encode_simple_pointer(enc, val->pInputAssemblyState))
1884 vn_encode_VkPipelineInputAssemblyStateCreateInfo(enc, val->pInputAssemblyState);
1885 if (vn_encode_simple_pointer(enc, val->pTessellationState))
1886 vn_encode_VkPipelineTessellationStateCreateInfo(enc, val->pTessellationState);
1887 if (vn_encode_simple_pointer(enc, val->pViewportState))
1888 vn_encode_VkPipelineViewportStateCreateInfo(enc, val->pViewportState);
1889 if (vn_encode_simple_pointer(enc, val->pRasterizationState))
1890 vn_encode_VkPipelineRasterizationStateCreateInfo(enc, val->pRasterizationState);
1891 if (vn_encode_simple_pointer(enc, val->pMultisampleState))
1892 vn_encode_VkPipelineMultisampleStateCreateInfo(enc, val->pMultisampleState);
1893 if (vn_encode_simple_pointer(enc, val->pDepthStencilState))
1894 vn_encode_VkPipelineDepthStencilStateCreateInfo(enc, val->pDepthStencilState);
1895 if (vn_encode_simple_pointer(enc, val->pColorBlendState))
1896 vn_encode_VkPipelineColorBlendStateCreateInfo(enc, val->pColorBlendState);
1897 if (vn_encode_simple_pointer(enc, val->pDynamicState))
1898 vn_encode_VkPipelineDynamicStateCreateInfo(enc, val->pDynamicState);
1899 vn_encode_VkPipelineLayout(enc, &val->layout);
1900 vn_encode_VkRenderPass(enc, &val->renderPass);
1901 vn_encode_uint32_t(enc, &val->subpass);
1902 vn_encode_VkPipeline(enc, &val->basePipelineHandle);
1903 vn_encode_int32_t(enc, &val->basePipelineIndex);
1904 }
1905
1906 static inline void
vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder * enc,const VkGraphicsPipelineCreateInfo * val)1907 vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder *enc, const VkGraphicsPipelineCreateInfo *val)
1908 {
1909 assert(val->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
1910 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO });
1911 vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, val->pNext);
1912 vn_encode_VkGraphicsPipelineCreateInfo_self(enc, val);
1913 }
1914
1915 /* struct VkComputePipelineCreateInfo chain */
1916
1917 static inline size_t
vn_sizeof_VkComputePipelineCreateInfo_pnext(const void * val)1918 vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val)
1919 {
1920 const VkBaseInStructure *pnext = val;
1921 size_t size = 0;
1922
1923 while (pnext) {
1924 switch ((int32_t)pnext->sType) {
1925 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
1926 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
1927 break;
1928 size += vn_sizeof_simple_pointer(pnext);
1929 size += vn_sizeof_VkStructureType(&pnext->sType);
1930 size += vn_sizeof_VkComputePipelineCreateInfo_pnext(pnext->pNext);
1931 size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext);
1932 return size;
1933 default:
1934 /* ignore unknown/unsupported struct */
1935 break;
1936 }
1937 pnext = pnext->pNext;
1938 }
1939
1940 return vn_sizeof_simple_pointer(NULL);
1941 }
1942
1943 static inline size_t
vn_sizeof_VkComputePipelineCreateInfo_self(const VkComputePipelineCreateInfo * val)1944 vn_sizeof_VkComputePipelineCreateInfo_self(const VkComputePipelineCreateInfo *val)
1945 {
1946 size_t size = 0;
1947 /* skip val->{sType,pNext} */
1948 size += vn_sizeof_VkFlags(&val->flags);
1949 size += vn_sizeof_VkPipelineShaderStageCreateInfo(&val->stage);
1950 size += vn_sizeof_VkPipelineLayout(&val->layout);
1951 size += vn_sizeof_VkPipeline(&val->basePipelineHandle);
1952 size += vn_sizeof_int32_t(&val->basePipelineIndex);
1953 return size;
1954 }
1955
1956 static inline size_t
vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo * val)1957 vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *val)
1958 {
1959 size_t size = 0;
1960
1961 size += vn_sizeof_VkStructureType(&val->sType);
1962 size += vn_sizeof_VkComputePipelineCreateInfo_pnext(val->pNext);
1963 size += vn_sizeof_VkComputePipelineCreateInfo_self(val);
1964
1965 return size;
1966 }
1967
1968 static inline void
vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1969 vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1970 {
1971 const VkBaseInStructure *pnext = val;
1972
1973 while (pnext) {
1974 switch ((int32_t)pnext->sType) {
1975 case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
1976 if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
1977 break;
1978 vn_encode_simple_pointer(enc, pnext);
1979 vn_encode_VkStructureType(enc, &pnext->sType);
1980 vn_encode_VkComputePipelineCreateInfo_pnext(enc, pnext->pNext);
1981 vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext);
1982 return;
1983 default:
1984 /* ignore unknown/unsupported struct */
1985 break;
1986 }
1987 pnext = pnext->pNext;
1988 }
1989
1990 vn_encode_simple_pointer(enc, NULL);
1991 }
1992
1993 static inline void
vn_encode_VkComputePipelineCreateInfo_self(struct vn_cs_encoder * enc,const VkComputePipelineCreateInfo * val)1994 vn_encode_VkComputePipelineCreateInfo_self(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
1995 {
1996 /* skip val->{sType,pNext} */
1997 vn_encode_VkFlags(enc, &val->flags);
1998 vn_encode_VkPipelineShaderStageCreateInfo(enc, &val->stage);
1999 vn_encode_VkPipelineLayout(enc, &val->layout);
2000 vn_encode_VkPipeline(enc, &val->basePipelineHandle);
2001 vn_encode_int32_t(enc, &val->basePipelineIndex);
2002 }
2003
2004 static inline void
vn_encode_VkComputePipelineCreateInfo(struct vn_cs_encoder * enc,const VkComputePipelineCreateInfo * val)2005 vn_encode_VkComputePipelineCreateInfo(struct vn_cs_encoder *enc, const VkComputePipelineCreateInfo *val)
2006 {
2007 assert(val->sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO);
2008 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO });
2009 vn_encode_VkComputePipelineCreateInfo_pnext(enc, val->pNext);
2010 vn_encode_VkComputePipelineCreateInfo_self(enc, val);
2011 }
2012
vn_sizeof_vkCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2013 static inline size_t vn_sizeof_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2014 {
2015 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
2016 const VkFlags cmd_flags = 0;
2017 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2018
2019 cmd_size += vn_sizeof_VkDevice(&device);
2020 cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
2021 cmd_size += vn_sizeof_uint32_t(&createInfoCount);
2022 if (pCreateInfos) {
2023 cmd_size += vn_sizeof_array_size(createInfoCount);
2024 for (uint32_t i = 0; i < createInfoCount; i++)
2025 cmd_size += vn_sizeof_VkGraphicsPipelineCreateInfo(&pCreateInfos[i]);
2026 } else {
2027 cmd_size += vn_sizeof_array_size(0);
2028 }
2029 cmd_size += vn_sizeof_simple_pointer(pAllocator);
2030 if (pAllocator)
2031 assert(false);
2032 if (pPipelines) {
2033 cmd_size += vn_sizeof_array_size(createInfoCount);
2034 for (uint32_t i = 0; i < createInfoCount; i++)
2035 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2036 } else {
2037 cmd_size += vn_sizeof_array_size(0);
2038 }
2039
2040 return cmd_size;
2041 }
2042
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)2043 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)
2044 {
2045 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
2046
2047 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2048 vn_encode_VkFlags(enc, &cmd_flags);
2049
2050 vn_encode_VkDevice(enc, &device);
2051 vn_encode_VkPipelineCache(enc, &pipelineCache);
2052 vn_encode_uint32_t(enc, &createInfoCount);
2053 if (pCreateInfos) {
2054 vn_encode_array_size(enc, createInfoCount);
2055 for (uint32_t i = 0; i < createInfoCount; i++)
2056 vn_encode_VkGraphicsPipelineCreateInfo(enc, &pCreateInfos[i]);
2057 } else {
2058 vn_encode_array_size(enc, 0);
2059 }
2060 if (vn_encode_simple_pointer(enc, pAllocator))
2061 assert(false);
2062 if (pPipelines) {
2063 vn_encode_array_size(enc, createInfoCount);
2064 for (uint32_t i = 0; i < createInfoCount; i++)
2065 vn_encode_VkPipeline(enc, &pPipelines[i]);
2066 } else {
2067 vn_encode_array_size(enc, 0);
2068 }
2069 }
2070
vn_sizeof_vkCreateGraphicsPipelines_reply(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2071 static inline size_t vn_sizeof_vkCreateGraphicsPipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2072 {
2073 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT;
2074 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2075
2076 VkResult ret;
2077 cmd_size += vn_sizeof_VkResult(&ret);
2078 /* skip device */
2079 /* skip pipelineCache */
2080 /* skip createInfoCount */
2081 /* skip pCreateInfos */
2082 /* skip pAllocator */
2083 if (pPipelines) {
2084 cmd_size += vn_sizeof_array_size(createInfoCount);
2085 for (uint32_t i = 0; i < createInfoCount; i++)
2086 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2087 } else {
2088 cmd_size += vn_sizeof_array_size(0);
2089 }
2090
2091 return cmd_size;
2092 }
2093
vn_decode_vkCreateGraphicsPipelines_reply(struct vn_cs_decoder * dec,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2094 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)
2095 {
2096 VkCommandTypeEXT command_type;
2097 vn_decode_VkCommandTypeEXT(dec, &command_type);
2098 assert(command_type == VK_COMMAND_TYPE_vkCreateGraphicsPipelines_EXT);
2099
2100 VkResult ret;
2101 vn_decode_VkResult(dec, &ret);
2102 /* skip device */
2103 /* skip pipelineCache */
2104 /* skip createInfoCount */
2105 /* skip pCreateInfos */
2106 /* skip pAllocator */
2107 if (vn_peek_array_size(dec)) {
2108 const uint32_t iter_count = vn_decode_array_size(dec, createInfoCount);
2109 for (uint32_t i = 0; i < iter_count; i++)
2110 vn_decode_VkPipeline(dec, &pPipelines[i]);
2111 } else {
2112 vn_decode_array_size_unchecked(dec);
2113 pPipelines = NULL;
2114 }
2115
2116 return ret;
2117 }
2118
vn_sizeof_vkCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2119 static inline size_t vn_sizeof_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2120 {
2121 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
2122 const VkFlags cmd_flags = 0;
2123 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2124
2125 cmd_size += vn_sizeof_VkDevice(&device);
2126 cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
2127 cmd_size += vn_sizeof_uint32_t(&createInfoCount);
2128 if (pCreateInfos) {
2129 cmd_size += vn_sizeof_array_size(createInfoCount);
2130 for (uint32_t i = 0; i < createInfoCount; i++)
2131 cmd_size += vn_sizeof_VkComputePipelineCreateInfo(&pCreateInfos[i]);
2132 } else {
2133 cmd_size += vn_sizeof_array_size(0);
2134 }
2135 cmd_size += vn_sizeof_simple_pointer(pAllocator);
2136 if (pAllocator)
2137 assert(false);
2138 if (pPipelines) {
2139 cmd_size += vn_sizeof_array_size(createInfoCount);
2140 for (uint32_t i = 0; i < createInfoCount; i++)
2141 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2142 } else {
2143 cmd_size += vn_sizeof_array_size(0);
2144 }
2145
2146 return cmd_size;
2147 }
2148
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)2149 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)
2150 {
2151 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
2152
2153 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2154 vn_encode_VkFlags(enc, &cmd_flags);
2155
2156 vn_encode_VkDevice(enc, &device);
2157 vn_encode_VkPipelineCache(enc, &pipelineCache);
2158 vn_encode_uint32_t(enc, &createInfoCount);
2159 if (pCreateInfos) {
2160 vn_encode_array_size(enc, createInfoCount);
2161 for (uint32_t i = 0; i < createInfoCount; i++)
2162 vn_encode_VkComputePipelineCreateInfo(enc, &pCreateInfos[i]);
2163 } else {
2164 vn_encode_array_size(enc, 0);
2165 }
2166 if (vn_encode_simple_pointer(enc, pAllocator))
2167 assert(false);
2168 if (pPipelines) {
2169 vn_encode_array_size(enc, createInfoCount);
2170 for (uint32_t i = 0; i < createInfoCount; i++)
2171 vn_encode_VkPipeline(enc, &pPipelines[i]);
2172 } else {
2173 vn_encode_array_size(enc, 0);
2174 }
2175 }
2176
vn_sizeof_vkCreateComputePipelines_reply(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2177 static inline size_t vn_sizeof_vkCreateComputePipelines_reply(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2178 {
2179 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateComputePipelines_EXT;
2180 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2181
2182 VkResult ret;
2183 cmd_size += vn_sizeof_VkResult(&ret);
2184 /* skip device */
2185 /* skip pipelineCache */
2186 /* skip createInfoCount */
2187 /* skip pCreateInfos */
2188 /* skip pAllocator */
2189 if (pPipelines) {
2190 cmd_size += vn_sizeof_array_size(createInfoCount);
2191 for (uint32_t i = 0; i < createInfoCount; i++)
2192 cmd_size += vn_sizeof_VkPipeline(&pPipelines[i]);
2193 } else {
2194 cmd_size += vn_sizeof_array_size(0);
2195 }
2196
2197 return cmd_size;
2198 }
2199
vn_decode_vkCreateComputePipelines_reply(struct vn_cs_decoder * dec,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2200 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)
2201 {
2202 VkCommandTypeEXT command_type;
2203 vn_decode_VkCommandTypeEXT(dec, &command_type);
2204 assert(command_type == VK_COMMAND_TYPE_vkCreateComputePipelines_EXT);
2205
2206 VkResult ret;
2207 vn_decode_VkResult(dec, &ret);
2208 /* skip device */
2209 /* skip pipelineCache */
2210 /* skip createInfoCount */
2211 /* skip pCreateInfos */
2212 /* skip pAllocator */
2213 if (vn_peek_array_size(dec)) {
2214 const uint32_t iter_count = vn_decode_array_size(dec, createInfoCount);
2215 for (uint32_t i = 0; i < iter_count; i++)
2216 vn_decode_VkPipeline(dec, &pPipelines[i]);
2217 } else {
2218 vn_decode_array_size_unchecked(dec);
2219 pPipelines = NULL;
2220 }
2221
2222 return ret;
2223 }
2224
vn_sizeof_vkDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2225 static inline size_t vn_sizeof_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2226 {
2227 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
2228 const VkFlags cmd_flags = 0;
2229 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
2230
2231 cmd_size += vn_sizeof_VkDevice(&device);
2232 cmd_size += vn_sizeof_VkPipeline(&pipeline);
2233 cmd_size += vn_sizeof_simple_pointer(pAllocator);
2234 if (pAllocator)
2235 assert(false);
2236
2237 return cmd_size;
2238 }
2239
vn_encode_vkDestroyPipeline(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2240 static inline void vn_encode_vkDestroyPipeline(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2241 {
2242 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
2243
2244 vn_encode_VkCommandTypeEXT(enc, &cmd_type);
2245 vn_encode_VkFlags(enc, &cmd_flags);
2246
2247 vn_encode_VkDevice(enc, &device);
2248 vn_encode_VkPipeline(enc, &pipeline);
2249 if (vn_encode_simple_pointer(enc, pAllocator))
2250 assert(false);
2251 }
2252
vn_sizeof_vkDestroyPipeline_reply(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2253 static inline size_t vn_sizeof_vkDestroyPipeline_reply(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2254 {
2255 const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipeline_EXT;
2256 size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
2257
2258 /* skip device */
2259 /* skip pipeline */
2260 /* skip pAllocator */
2261
2262 return cmd_size;
2263 }
2264
vn_decode_vkDestroyPipeline_reply(struct vn_cs_decoder * dec,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2265 static inline void vn_decode_vkDestroyPipeline_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2266 {
2267 VkCommandTypeEXT command_type;
2268 vn_decode_VkCommandTypeEXT(dec, &command_type);
2269 assert(command_type == VK_COMMAND_TYPE_vkDestroyPipeline_EXT);
2270
2271 /* skip device */
2272 /* skip pipeline */
2273 /* skip pAllocator */
2274 }
2275
vn_submit_vkCreateGraphicsPipelines(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,struct vn_instance_submit_command * submit)2276 static inline void vn_submit_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit)
2277 {
2278 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2279 void *cmd_data = local_cmd_data;
2280 size_t cmd_size = vn_sizeof_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2281 if (cmd_size > sizeof(local_cmd_data)) {
2282 cmd_data = malloc(cmd_size);
2283 if (!cmd_data)
2284 cmd_size = 0;
2285 }
2286 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateGraphicsPipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
2287
2288 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2289 if (cmd_size) {
2290 vn_encode_vkCreateGraphicsPipelines(enc, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2291 vn_instance_submit_command(vn_instance, submit);
2292 if (cmd_data != local_cmd_data)
2293 free(cmd_data);
2294 }
2295 }
2296
vn_submit_vkCreateComputePipelines(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,struct vn_instance_submit_command * submit)2297 static inline void vn_submit_vkCreateComputePipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit)
2298 {
2299 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2300 void *cmd_data = local_cmd_data;
2301 size_t cmd_size = vn_sizeof_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2302 if (cmd_size > sizeof(local_cmd_data)) {
2303 cmd_data = malloc(cmd_size);
2304 if (!cmd_data)
2305 cmd_size = 0;
2306 }
2307 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateComputePipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
2308
2309 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2310 if (cmd_size) {
2311 vn_encode_vkCreateComputePipelines(enc, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2312 vn_instance_submit_command(vn_instance, submit);
2313 if (cmd_data != local_cmd_data)
2314 free(cmd_data);
2315 }
2316 }
2317
vn_submit_vkDestroyPipeline(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator,struct vn_instance_submit_command * submit)2318 static inline void vn_submit_vkDestroyPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
2319 {
2320 uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
2321 void *cmd_data = local_cmd_data;
2322 size_t cmd_size = vn_sizeof_vkDestroyPipeline(device, pipeline, pAllocator);
2323 if (cmd_size > sizeof(local_cmd_data)) {
2324 cmd_data = malloc(cmd_size);
2325 if (!cmd_data)
2326 cmd_size = 0;
2327 }
2328 const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipeline_reply(device, pipeline, pAllocator) : 0;
2329
2330 struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
2331 if (cmd_size) {
2332 vn_encode_vkDestroyPipeline(enc, cmd_flags, device, pipeline, pAllocator);
2333 vn_instance_submit_command(vn_instance, submit);
2334 if (cmd_data != local_cmd_data)
2335 free(cmd_data);
2336 }
2337 }
2338
vn_call_vkCreateGraphicsPipelines(struct vn_instance * vn_instance,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2339 static inline VkResult vn_call_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2340 {
2341 VN_TRACE_FUNC();
2342
2343 struct vn_instance_submit_command submit;
2344 vn_submit_vkCreateGraphicsPipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2345 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2346 if (dec) {
2347 const VkResult ret = vn_decode_vkCreateGraphicsPipelines_reply(dec, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2348 vn_instance_free_command_reply(vn_instance, &submit);
2349 return ret;
2350 } else {
2351 return VK_ERROR_OUT_OF_HOST_MEMORY;
2352 }
2353 }
2354
vn_async_vkCreateGraphicsPipelines(struct vn_instance * vn_instance,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2355 static inline void vn_async_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2356 {
2357 struct vn_instance_submit_command submit;
2358 vn_submit_vkCreateGraphicsPipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2359 }
2360
vn_call_vkCreateComputePipelines(struct vn_instance * vn_instance,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2361 static inline VkResult vn_call_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2362 {
2363 VN_TRACE_FUNC();
2364
2365 struct vn_instance_submit_command submit;
2366 vn_submit_vkCreateComputePipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2367 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2368 if (dec) {
2369 const VkResult ret = vn_decode_vkCreateComputePipelines_reply(dec, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
2370 vn_instance_free_command_reply(vn_instance, &submit);
2371 return ret;
2372 } else {
2373 return VK_ERROR_OUT_OF_HOST_MEMORY;
2374 }
2375 }
2376
vn_async_vkCreateComputePipelines(struct vn_instance * vn_instance,VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2377 static inline void vn_async_vkCreateComputePipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
2378 {
2379 struct vn_instance_submit_command submit;
2380 vn_submit_vkCreateComputePipelines(vn_instance, 0, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
2381 }
2382
vn_call_vkDestroyPipeline(struct vn_instance * vn_instance,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2383 static inline void vn_call_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2384 {
2385 VN_TRACE_FUNC();
2386
2387 struct vn_instance_submit_command submit;
2388 vn_submit_vkDestroyPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipeline, pAllocator, &submit);
2389 struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
2390 if (dec) {
2391 vn_decode_vkDestroyPipeline_reply(dec, device, pipeline, pAllocator);
2392 vn_instance_free_command_reply(vn_instance, &submit);
2393 }
2394 }
2395
vn_async_vkDestroyPipeline(struct vn_instance * vn_instance,VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2396 static inline void vn_async_vkDestroyPipeline(struct vn_instance *vn_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
2397 {
2398 struct vn_instance_submit_command submit;
2399 vn_submit_vkDestroyPipeline(vn_instance, 0, device, pipeline, pAllocator, &submit);
2400 }
2401
2402 #endif /* VN_PROTOCOL_DRIVER_PIPELINE_H */
2403