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