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_DEVICE_H
9 #define VN_PROTOCOL_DRIVER_DEVICE_H
10 
11 #include "vn_instance.h"
12 #include "vn_protocol_driver_structs.h"
13 
14 /*
15  * These structs/unions/commands are not included
16  *
17  *   vkGetDeviceProcAddr
18  */
19 
20 /* struct VkPhysicalDeviceLimits */
21 
22 static inline size_t
vn_sizeof_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits * val)23 vn_sizeof_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits *val)
24 {
25     size_t size = 0;
26     size += vn_sizeof_uint32_t(&val->maxImageDimension1D);
27     size += vn_sizeof_uint32_t(&val->maxImageDimension2D);
28     size += vn_sizeof_uint32_t(&val->maxImageDimension3D);
29     size += vn_sizeof_uint32_t(&val->maxImageDimensionCube);
30     size += vn_sizeof_uint32_t(&val->maxImageArrayLayers);
31     size += vn_sizeof_uint32_t(&val->maxTexelBufferElements);
32     size += vn_sizeof_uint32_t(&val->maxUniformBufferRange);
33     size += vn_sizeof_uint32_t(&val->maxStorageBufferRange);
34     size += vn_sizeof_uint32_t(&val->maxPushConstantsSize);
35     size += vn_sizeof_uint32_t(&val->maxMemoryAllocationCount);
36     size += vn_sizeof_uint32_t(&val->maxSamplerAllocationCount);
37     size += vn_sizeof_VkDeviceSize(&val->bufferImageGranularity);
38     size += vn_sizeof_VkDeviceSize(&val->sparseAddressSpaceSize);
39     size += vn_sizeof_uint32_t(&val->maxBoundDescriptorSets);
40     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSamplers);
41     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUniformBuffers);
42     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageBuffers);
43     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorSampledImages);
44     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorStorageImages);
45     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInputAttachments);
46     size += vn_sizeof_uint32_t(&val->maxPerStageResources);
47     size += vn_sizeof_uint32_t(&val->maxDescriptorSetSamplers);
48     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffers);
49     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUniformBuffersDynamic);
50     size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffers);
51     size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageBuffersDynamic);
52     size += vn_sizeof_uint32_t(&val->maxDescriptorSetSampledImages);
53     size += vn_sizeof_uint32_t(&val->maxDescriptorSetStorageImages);
54     size += vn_sizeof_uint32_t(&val->maxDescriptorSetInputAttachments);
55     size += vn_sizeof_uint32_t(&val->maxVertexInputAttributes);
56     size += vn_sizeof_uint32_t(&val->maxVertexInputBindings);
57     size += vn_sizeof_uint32_t(&val->maxVertexInputAttributeOffset);
58     size += vn_sizeof_uint32_t(&val->maxVertexInputBindingStride);
59     size += vn_sizeof_uint32_t(&val->maxVertexOutputComponents);
60     size += vn_sizeof_uint32_t(&val->maxTessellationGenerationLevel);
61     size += vn_sizeof_uint32_t(&val->maxTessellationPatchSize);
62     size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexInputComponents);
63     size += vn_sizeof_uint32_t(&val->maxTessellationControlPerVertexOutputComponents);
64     size += vn_sizeof_uint32_t(&val->maxTessellationControlPerPatchOutputComponents);
65     size += vn_sizeof_uint32_t(&val->maxTessellationControlTotalOutputComponents);
66     size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationInputComponents);
67     size += vn_sizeof_uint32_t(&val->maxTessellationEvaluationOutputComponents);
68     size += vn_sizeof_uint32_t(&val->maxGeometryShaderInvocations);
69     size += vn_sizeof_uint32_t(&val->maxGeometryInputComponents);
70     size += vn_sizeof_uint32_t(&val->maxGeometryOutputComponents);
71     size += vn_sizeof_uint32_t(&val->maxGeometryOutputVertices);
72     size += vn_sizeof_uint32_t(&val->maxGeometryTotalOutputComponents);
73     size += vn_sizeof_uint32_t(&val->maxFragmentInputComponents);
74     size += vn_sizeof_uint32_t(&val->maxFragmentOutputAttachments);
75     size += vn_sizeof_uint32_t(&val->maxFragmentDualSrcAttachments);
76     size += vn_sizeof_uint32_t(&val->maxFragmentCombinedOutputResources);
77     size += vn_sizeof_uint32_t(&val->maxComputeSharedMemorySize);
78     size += vn_sizeof_array_size(3);
79     size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupCount, 3);
80     size += vn_sizeof_uint32_t(&val->maxComputeWorkGroupInvocations);
81     size += vn_sizeof_array_size(3);
82     size += vn_sizeof_uint32_t_array(val->maxComputeWorkGroupSize, 3);
83     size += vn_sizeof_uint32_t(&val->subPixelPrecisionBits);
84     size += vn_sizeof_uint32_t(&val->subTexelPrecisionBits);
85     size += vn_sizeof_uint32_t(&val->mipmapPrecisionBits);
86     size += vn_sizeof_uint32_t(&val->maxDrawIndexedIndexValue);
87     size += vn_sizeof_uint32_t(&val->maxDrawIndirectCount);
88     size += vn_sizeof_float(&val->maxSamplerLodBias);
89     size += vn_sizeof_float(&val->maxSamplerAnisotropy);
90     size += vn_sizeof_uint32_t(&val->maxViewports);
91     size += vn_sizeof_array_size(2);
92     size += vn_sizeof_uint32_t_array(val->maxViewportDimensions, 2);
93     size += vn_sizeof_array_size(2);
94     size += vn_sizeof_float_array(val->viewportBoundsRange, 2);
95     size += vn_sizeof_uint32_t(&val->viewportSubPixelBits);
96     size += vn_sizeof_size_t(&val->minMemoryMapAlignment);
97     size += vn_sizeof_VkDeviceSize(&val->minTexelBufferOffsetAlignment);
98     size += vn_sizeof_VkDeviceSize(&val->minUniformBufferOffsetAlignment);
99     size += vn_sizeof_VkDeviceSize(&val->minStorageBufferOffsetAlignment);
100     size += vn_sizeof_int32_t(&val->minTexelOffset);
101     size += vn_sizeof_uint32_t(&val->maxTexelOffset);
102     size += vn_sizeof_int32_t(&val->minTexelGatherOffset);
103     size += vn_sizeof_uint32_t(&val->maxTexelGatherOffset);
104     size += vn_sizeof_float(&val->minInterpolationOffset);
105     size += vn_sizeof_float(&val->maxInterpolationOffset);
106     size += vn_sizeof_uint32_t(&val->subPixelInterpolationOffsetBits);
107     size += vn_sizeof_uint32_t(&val->maxFramebufferWidth);
108     size += vn_sizeof_uint32_t(&val->maxFramebufferHeight);
109     size += vn_sizeof_uint32_t(&val->maxFramebufferLayers);
110     size += vn_sizeof_VkFlags(&val->framebufferColorSampleCounts);
111     size += vn_sizeof_VkFlags(&val->framebufferDepthSampleCounts);
112     size += vn_sizeof_VkFlags(&val->framebufferStencilSampleCounts);
113     size += vn_sizeof_VkFlags(&val->framebufferNoAttachmentsSampleCounts);
114     size += vn_sizeof_uint32_t(&val->maxColorAttachments);
115     size += vn_sizeof_VkFlags(&val->sampledImageColorSampleCounts);
116     size += vn_sizeof_VkFlags(&val->sampledImageIntegerSampleCounts);
117     size += vn_sizeof_VkFlags(&val->sampledImageDepthSampleCounts);
118     size += vn_sizeof_VkFlags(&val->sampledImageStencilSampleCounts);
119     size += vn_sizeof_VkFlags(&val->storageImageSampleCounts);
120     size += vn_sizeof_uint32_t(&val->maxSampleMaskWords);
121     size += vn_sizeof_VkBool32(&val->timestampComputeAndGraphics);
122     size += vn_sizeof_float(&val->timestampPeriod);
123     size += vn_sizeof_uint32_t(&val->maxClipDistances);
124     size += vn_sizeof_uint32_t(&val->maxCullDistances);
125     size += vn_sizeof_uint32_t(&val->maxCombinedClipAndCullDistances);
126     size += vn_sizeof_uint32_t(&val->discreteQueuePriorities);
127     size += vn_sizeof_array_size(2);
128     size += vn_sizeof_float_array(val->pointSizeRange, 2);
129     size += vn_sizeof_array_size(2);
130     size += vn_sizeof_float_array(val->lineWidthRange, 2);
131     size += vn_sizeof_float(&val->pointSizeGranularity);
132     size += vn_sizeof_float(&val->lineWidthGranularity);
133     size += vn_sizeof_VkBool32(&val->strictLines);
134     size += vn_sizeof_VkBool32(&val->standardSampleLocations);
135     size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyOffsetAlignment);
136     size += vn_sizeof_VkDeviceSize(&val->optimalBufferCopyRowPitchAlignment);
137     size += vn_sizeof_VkDeviceSize(&val->nonCoherentAtomSize);
138     return size;
139 }
140 
141 static inline void
vn_decode_VkPhysicalDeviceLimits(struct vn_cs_decoder * dec,VkPhysicalDeviceLimits * val)142 vn_decode_VkPhysicalDeviceLimits(struct vn_cs_decoder *dec, VkPhysicalDeviceLimits *val)
143 {
144     vn_decode_uint32_t(dec, &val->maxImageDimension1D);
145     vn_decode_uint32_t(dec, &val->maxImageDimension2D);
146     vn_decode_uint32_t(dec, &val->maxImageDimension3D);
147     vn_decode_uint32_t(dec, &val->maxImageDimensionCube);
148     vn_decode_uint32_t(dec, &val->maxImageArrayLayers);
149     vn_decode_uint32_t(dec, &val->maxTexelBufferElements);
150     vn_decode_uint32_t(dec, &val->maxUniformBufferRange);
151     vn_decode_uint32_t(dec, &val->maxStorageBufferRange);
152     vn_decode_uint32_t(dec, &val->maxPushConstantsSize);
153     vn_decode_uint32_t(dec, &val->maxMemoryAllocationCount);
154     vn_decode_uint32_t(dec, &val->maxSamplerAllocationCount);
155     vn_decode_VkDeviceSize(dec, &val->bufferImageGranularity);
156     vn_decode_VkDeviceSize(dec, &val->sparseAddressSpaceSize);
157     vn_decode_uint32_t(dec, &val->maxBoundDescriptorSets);
158     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSamplers);
159     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUniformBuffers);
160     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageBuffers);
161     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorSampledImages);
162     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorStorageImages);
163     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInputAttachments);
164     vn_decode_uint32_t(dec, &val->maxPerStageResources);
165     vn_decode_uint32_t(dec, &val->maxDescriptorSetSamplers);
166     vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffers);
167     vn_decode_uint32_t(dec, &val->maxDescriptorSetUniformBuffersDynamic);
168     vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffers);
169     vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageBuffersDynamic);
170     vn_decode_uint32_t(dec, &val->maxDescriptorSetSampledImages);
171     vn_decode_uint32_t(dec, &val->maxDescriptorSetStorageImages);
172     vn_decode_uint32_t(dec, &val->maxDescriptorSetInputAttachments);
173     vn_decode_uint32_t(dec, &val->maxVertexInputAttributes);
174     vn_decode_uint32_t(dec, &val->maxVertexInputBindings);
175     vn_decode_uint32_t(dec, &val->maxVertexInputAttributeOffset);
176     vn_decode_uint32_t(dec, &val->maxVertexInputBindingStride);
177     vn_decode_uint32_t(dec, &val->maxVertexOutputComponents);
178     vn_decode_uint32_t(dec, &val->maxTessellationGenerationLevel);
179     vn_decode_uint32_t(dec, &val->maxTessellationPatchSize);
180     vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexInputComponents);
181     vn_decode_uint32_t(dec, &val->maxTessellationControlPerVertexOutputComponents);
182     vn_decode_uint32_t(dec, &val->maxTessellationControlPerPatchOutputComponents);
183     vn_decode_uint32_t(dec, &val->maxTessellationControlTotalOutputComponents);
184     vn_decode_uint32_t(dec, &val->maxTessellationEvaluationInputComponents);
185     vn_decode_uint32_t(dec, &val->maxTessellationEvaluationOutputComponents);
186     vn_decode_uint32_t(dec, &val->maxGeometryShaderInvocations);
187     vn_decode_uint32_t(dec, &val->maxGeometryInputComponents);
188     vn_decode_uint32_t(dec, &val->maxGeometryOutputComponents);
189     vn_decode_uint32_t(dec, &val->maxGeometryOutputVertices);
190     vn_decode_uint32_t(dec, &val->maxGeometryTotalOutputComponents);
191     vn_decode_uint32_t(dec, &val->maxFragmentInputComponents);
192     vn_decode_uint32_t(dec, &val->maxFragmentOutputAttachments);
193     vn_decode_uint32_t(dec, &val->maxFragmentDualSrcAttachments);
194     vn_decode_uint32_t(dec, &val->maxFragmentCombinedOutputResources);
195     vn_decode_uint32_t(dec, &val->maxComputeSharedMemorySize);
196     {
197         const size_t array_size = vn_decode_array_size(dec, 3);
198         vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupCount, array_size);
199     }
200     vn_decode_uint32_t(dec, &val->maxComputeWorkGroupInvocations);
201     {
202         const size_t array_size = vn_decode_array_size(dec, 3);
203         vn_decode_uint32_t_array(dec, val->maxComputeWorkGroupSize, array_size);
204     }
205     vn_decode_uint32_t(dec, &val->subPixelPrecisionBits);
206     vn_decode_uint32_t(dec, &val->subTexelPrecisionBits);
207     vn_decode_uint32_t(dec, &val->mipmapPrecisionBits);
208     vn_decode_uint32_t(dec, &val->maxDrawIndexedIndexValue);
209     vn_decode_uint32_t(dec, &val->maxDrawIndirectCount);
210     vn_decode_float(dec, &val->maxSamplerLodBias);
211     vn_decode_float(dec, &val->maxSamplerAnisotropy);
212     vn_decode_uint32_t(dec, &val->maxViewports);
213     {
214         const size_t array_size = vn_decode_array_size(dec, 2);
215         vn_decode_uint32_t_array(dec, val->maxViewportDimensions, array_size);
216     }
217     {
218         const size_t array_size = vn_decode_array_size(dec, 2);
219         vn_decode_float_array(dec, val->viewportBoundsRange, array_size);
220     }
221     vn_decode_uint32_t(dec, &val->viewportSubPixelBits);
222     vn_decode_size_t(dec, &val->minMemoryMapAlignment);
223     vn_decode_VkDeviceSize(dec, &val->minTexelBufferOffsetAlignment);
224     vn_decode_VkDeviceSize(dec, &val->minUniformBufferOffsetAlignment);
225     vn_decode_VkDeviceSize(dec, &val->minStorageBufferOffsetAlignment);
226     vn_decode_int32_t(dec, &val->minTexelOffset);
227     vn_decode_uint32_t(dec, &val->maxTexelOffset);
228     vn_decode_int32_t(dec, &val->minTexelGatherOffset);
229     vn_decode_uint32_t(dec, &val->maxTexelGatherOffset);
230     vn_decode_float(dec, &val->minInterpolationOffset);
231     vn_decode_float(dec, &val->maxInterpolationOffset);
232     vn_decode_uint32_t(dec, &val->subPixelInterpolationOffsetBits);
233     vn_decode_uint32_t(dec, &val->maxFramebufferWidth);
234     vn_decode_uint32_t(dec, &val->maxFramebufferHeight);
235     vn_decode_uint32_t(dec, &val->maxFramebufferLayers);
236     vn_decode_VkFlags(dec, &val->framebufferColorSampleCounts);
237     vn_decode_VkFlags(dec, &val->framebufferDepthSampleCounts);
238     vn_decode_VkFlags(dec, &val->framebufferStencilSampleCounts);
239     vn_decode_VkFlags(dec, &val->framebufferNoAttachmentsSampleCounts);
240     vn_decode_uint32_t(dec, &val->maxColorAttachments);
241     vn_decode_VkFlags(dec, &val->sampledImageColorSampleCounts);
242     vn_decode_VkFlags(dec, &val->sampledImageIntegerSampleCounts);
243     vn_decode_VkFlags(dec, &val->sampledImageDepthSampleCounts);
244     vn_decode_VkFlags(dec, &val->sampledImageStencilSampleCounts);
245     vn_decode_VkFlags(dec, &val->storageImageSampleCounts);
246     vn_decode_uint32_t(dec, &val->maxSampleMaskWords);
247     vn_decode_VkBool32(dec, &val->timestampComputeAndGraphics);
248     vn_decode_float(dec, &val->timestampPeriod);
249     vn_decode_uint32_t(dec, &val->maxClipDistances);
250     vn_decode_uint32_t(dec, &val->maxCullDistances);
251     vn_decode_uint32_t(dec, &val->maxCombinedClipAndCullDistances);
252     vn_decode_uint32_t(dec, &val->discreteQueuePriorities);
253     {
254         const size_t array_size = vn_decode_array_size(dec, 2);
255         vn_decode_float_array(dec, val->pointSizeRange, array_size);
256     }
257     {
258         const size_t array_size = vn_decode_array_size(dec, 2);
259         vn_decode_float_array(dec, val->lineWidthRange, array_size);
260     }
261     vn_decode_float(dec, &val->pointSizeGranularity);
262     vn_decode_float(dec, &val->lineWidthGranularity);
263     vn_decode_VkBool32(dec, &val->strictLines);
264     vn_decode_VkBool32(dec, &val->standardSampleLocations);
265     vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyOffsetAlignment);
266     vn_decode_VkDeviceSize(dec, &val->optimalBufferCopyRowPitchAlignment);
267     vn_decode_VkDeviceSize(dec, &val->nonCoherentAtomSize);
268 }
269 
270 static inline size_t
vn_sizeof_VkPhysicalDeviceLimits_partial(const VkPhysicalDeviceLimits * val)271 vn_sizeof_VkPhysicalDeviceLimits_partial(const VkPhysicalDeviceLimits *val)
272 {
273     size_t size = 0;
274     /* skip val->maxImageDimension1D */
275     /* skip val->maxImageDimension2D */
276     /* skip val->maxImageDimension3D */
277     /* skip val->maxImageDimensionCube */
278     /* skip val->maxImageArrayLayers */
279     /* skip val->maxTexelBufferElements */
280     /* skip val->maxUniformBufferRange */
281     /* skip val->maxStorageBufferRange */
282     /* skip val->maxPushConstantsSize */
283     /* skip val->maxMemoryAllocationCount */
284     /* skip val->maxSamplerAllocationCount */
285     /* skip val->bufferImageGranularity */
286     /* skip val->sparseAddressSpaceSize */
287     /* skip val->maxBoundDescriptorSets */
288     /* skip val->maxPerStageDescriptorSamplers */
289     /* skip val->maxPerStageDescriptorUniformBuffers */
290     /* skip val->maxPerStageDescriptorStorageBuffers */
291     /* skip val->maxPerStageDescriptorSampledImages */
292     /* skip val->maxPerStageDescriptorStorageImages */
293     /* skip val->maxPerStageDescriptorInputAttachments */
294     /* skip val->maxPerStageResources */
295     /* skip val->maxDescriptorSetSamplers */
296     /* skip val->maxDescriptorSetUniformBuffers */
297     /* skip val->maxDescriptorSetUniformBuffersDynamic */
298     /* skip val->maxDescriptorSetStorageBuffers */
299     /* skip val->maxDescriptorSetStorageBuffersDynamic */
300     /* skip val->maxDescriptorSetSampledImages */
301     /* skip val->maxDescriptorSetStorageImages */
302     /* skip val->maxDescriptorSetInputAttachments */
303     /* skip val->maxVertexInputAttributes */
304     /* skip val->maxVertexInputBindings */
305     /* skip val->maxVertexInputAttributeOffset */
306     /* skip val->maxVertexInputBindingStride */
307     /* skip val->maxVertexOutputComponents */
308     /* skip val->maxTessellationGenerationLevel */
309     /* skip val->maxTessellationPatchSize */
310     /* skip val->maxTessellationControlPerVertexInputComponents */
311     /* skip val->maxTessellationControlPerVertexOutputComponents */
312     /* skip val->maxTessellationControlPerPatchOutputComponents */
313     /* skip val->maxTessellationControlTotalOutputComponents */
314     /* skip val->maxTessellationEvaluationInputComponents */
315     /* skip val->maxTessellationEvaluationOutputComponents */
316     /* skip val->maxGeometryShaderInvocations */
317     /* skip val->maxGeometryInputComponents */
318     /* skip val->maxGeometryOutputComponents */
319     /* skip val->maxGeometryOutputVertices */
320     /* skip val->maxGeometryTotalOutputComponents */
321     /* skip val->maxFragmentInputComponents */
322     /* skip val->maxFragmentOutputAttachments */
323     /* skip val->maxFragmentDualSrcAttachments */
324     /* skip val->maxFragmentCombinedOutputResources */
325     /* skip val->maxComputeSharedMemorySize */
326     /* skip val->maxComputeWorkGroupCount */
327     /* skip val->maxComputeWorkGroupInvocations */
328     /* skip val->maxComputeWorkGroupSize */
329     /* skip val->subPixelPrecisionBits */
330     /* skip val->subTexelPrecisionBits */
331     /* skip val->mipmapPrecisionBits */
332     /* skip val->maxDrawIndexedIndexValue */
333     /* skip val->maxDrawIndirectCount */
334     /* skip val->maxSamplerLodBias */
335     /* skip val->maxSamplerAnisotropy */
336     /* skip val->maxViewports */
337     /* skip val->maxViewportDimensions */
338     /* skip val->viewportBoundsRange */
339     /* skip val->viewportSubPixelBits */
340     /* skip val->minMemoryMapAlignment */
341     /* skip val->minTexelBufferOffsetAlignment */
342     /* skip val->minUniformBufferOffsetAlignment */
343     /* skip val->minStorageBufferOffsetAlignment */
344     /* skip val->minTexelOffset */
345     /* skip val->maxTexelOffset */
346     /* skip val->minTexelGatherOffset */
347     /* skip val->maxTexelGatherOffset */
348     /* skip val->minInterpolationOffset */
349     /* skip val->maxInterpolationOffset */
350     /* skip val->subPixelInterpolationOffsetBits */
351     /* skip val->maxFramebufferWidth */
352     /* skip val->maxFramebufferHeight */
353     /* skip val->maxFramebufferLayers */
354     /* skip val->framebufferColorSampleCounts */
355     /* skip val->framebufferDepthSampleCounts */
356     /* skip val->framebufferStencilSampleCounts */
357     /* skip val->framebufferNoAttachmentsSampleCounts */
358     /* skip val->maxColorAttachments */
359     /* skip val->sampledImageColorSampleCounts */
360     /* skip val->sampledImageIntegerSampleCounts */
361     /* skip val->sampledImageDepthSampleCounts */
362     /* skip val->sampledImageStencilSampleCounts */
363     /* skip val->storageImageSampleCounts */
364     /* skip val->maxSampleMaskWords */
365     /* skip val->timestampComputeAndGraphics */
366     /* skip val->timestampPeriod */
367     /* skip val->maxClipDistances */
368     /* skip val->maxCullDistances */
369     /* skip val->maxCombinedClipAndCullDistances */
370     /* skip val->discreteQueuePriorities */
371     /* skip val->pointSizeRange */
372     /* skip val->lineWidthRange */
373     /* skip val->pointSizeGranularity */
374     /* skip val->lineWidthGranularity */
375     /* skip val->strictLines */
376     /* skip val->standardSampleLocations */
377     /* skip val->optimalBufferCopyOffsetAlignment */
378     /* skip val->optimalBufferCopyRowPitchAlignment */
379     /* skip val->nonCoherentAtomSize */
380     return size;
381 }
382 
383 static inline void
vn_encode_VkPhysicalDeviceLimits_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLimits * val)384 vn_encode_VkPhysicalDeviceLimits_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLimits *val)
385 {
386     /* skip val->maxImageDimension1D */
387     /* skip val->maxImageDimension2D */
388     /* skip val->maxImageDimension3D */
389     /* skip val->maxImageDimensionCube */
390     /* skip val->maxImageArrayLayers */
391     /* skip val->maxTexelBufferElements */
392     /* skip val->maxUniformBufferRange */
393     /* skip val->maxStorageBufferRange */
394     /* skip val->maxPushConstantsSize */
395     /* skip val->maxMemoryAllocationCount */
396     /* skip val->maxSamplerAllocationCount */
397     /* skip val->bufferImageGranularity */
398     /* skip val->sparseAddressSpaceSize */
399     /* skip val->maxBoundDescriptorSets */
400     /* skip val->maxPerStageDescriptorSamplers */
401     /* skip val->maxPerStageDescriptorUniformBuffers */
402     /* skip val->maxPerStageDescriptorStorageBuffers */
403     /* skip val->maxPerStageDescriptorSampledImages */
404     /* skip val->maxPerStageDescriptorStorageImages */
405     /* skip val->maxPerStageDescriptorInputAttachments */
406     /* skip val->maxPerStageResources */
407     /* skip val->maxDescriptorSetSamplers */
408     /* skip val->maxDescriptorSetUniformBuffers */
409     /* skip val->maxDescriptorSetUniformBuffersDynamic */
410     /* skip val->maxDescriptorSetStorageBuffers */
411     /* skip val->maxDescriptorSetStorageBuffersDynamic */
412     /* skip val->maxDescriptorSetSampledImages */
413     /* skip val->maxDescriptorSetStorageImages */
414     /* skip val->maxDescriptorSetInputAttachments */
415     /* skip val->maxVertexInputAttributes */
416     /* skip val->maxVertexInputBindings */
417     /* skip val->maxVertexInputAttributeOffset */
418     /* skip val->maxVertexInputBindingStride */
419     /* skip val->maxVertexOutputComponents */
420     /* skip val->maxTessellationGenerationLevel */
421     /* skip val->maxTessellationPatchSize */
422     /* skip val->maxTessellationControlPerVertexInputComponents */
423     /* skip val->maxTessellationControlPerVertexOutputComponents */
424     /* skip val->maxTessellationControlPerPatchOutputComponents */
425     /* skip val->maxTessellationControlTotalOutputComponents */
426     /* skip val->maxTessellationEvaluationInputComponents */
427     /* skip val->maxTessellationEvaluationOutputComponents */
428     /* skip val->maxGeometryShaderInvocations */
429     /* skip val->maxGeometryInputComponents */
430     /* skip val->maxGeometryOutputComponents */
431     /* skip val->maxGeometryOutputVertices */
432     /* skip val->maxGeometryTotalOutputComponents */
433     /* skip val->maxFragmentInputComponents */
434     /* skip val->maxFragmentOutputAttachments */
435     /* skip val->maxFragmentDualSrcAttachments */
436     /* skip val->maxFragmentCombinedOutputResources */
437     /* skip val->maxComputeSharedMemorySize */
438     /* skip val->maxComputeWorkGroupCount */
439     /* skip val->maxComputeWorkGroupInvocations */
440     /* skip val->maxComputeWorkGroupSize */
441     /* skip val->subPixelPrecisionBits */
442     /* skip val->subTexelPrecisionBits */
443     /* skip val->mipmapPrecisionBits */
444     /* skip val->maxDrawIndexedIndexValue */
445     /* skip val->maxDrawIndirectCount */
446     /* skip val->maxSamplerLodBias */
447     /* skip val->maxSamplerAnisotropy */
448     /* skip val->maxViewports */
449     /* skip val->maxViewportDimensions */
450     /* skip val->viewportBoundsRange */
451     /* skip val->viewportSubPixelBits */
452     /* skip val->minMemoryMapAlignment */
453     /* skip val->minTexelBufferOffsetAlignment */
454     /* skip val->minUniformBufferOffsetAlignment */
455     /* skip val->minStorageBufferOffsetAlignment */
456     /* skip val->minTexelOffset */
457     /* skip val->maxTexelOffset */
458     /* skip val->minTexelGatherOffset */
459     /* skip val->maxTexelGatherOffset */
460     /* skip val->minInterpolationOffset */
461     /* skip val->maxInterpolationOffset */
462     /* skip val->subPixelInterpolationOffsetBits */
463     /* skip val->maxFramebufferWidth */
464     /* skip val->maxFramebufferHeight */
465     /* skip val->maxFramebufferLayers */
466     /* skip val->framebufferColorSampleCounts */
467     /* skip val->framebufferDepthSampleCounts */
468     /* skip val->framebufferStencilSampleCounts */
469     /* skip val->framebufferNoAttachmentsSampleCounts */
470     /* skip val->maxColorAttachments */
471     /* skip val->sampledImageColorSampleCounts */
472     /* skip val->sampledImageIntegerSampleCounts */
473     /* skip val->sampledImageDepthSampleCounts */
474     /* skip val->sampledImageStencilSampleCounts */
475     /* skip val->storageImageSampleCounts */
476     /* skip val->maxSampleMaskWords */
477     /* skip val->timestampComputeAndGraphics */
478     /* skip val->timestampPeriod */
479     /* skip val->maxClipDistances */
480     /* skip val->maxCullDistances */
481     /* skip val->maxCombinedClipAndCullDistances */
482     /* skip val->discreteQueuePriorities */
483     /* skip val->pointSizeRange */
484     /* skip val->lineWidthRange */
485     /* skip val->pointSizeGranularity */
486     /* skip val->lineWidthGranularity */
487     /* skip val->strictLines */
488     /* skip val->standardSampleLocations */
489     /* skip val->optimalBufferCopyOffsetAlignment */
490     /* skip val->optimalBufferCopyRowPitchAlignment */
491     /* skip val->nonCoherentAtomSize */
492 }
493 
494 /* struct VkPhysicalDeviceSparseProperties */
495 
496 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties * val)497 vn_sizeof_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties *val)
498 {
499     size_t size = 0;
500     size += vn_sizeof_VkBool32(&val->residencyStandard2DBlockShape);
501     size += vn_sizeof_VkBool32(&val->residencyStandard2DMultisampleBlockShape);
502     size += vn_sizeof_VkBool32(&val->residencyStandard3DBlockShape);
503     size += vn_sizeof_VkBool32(&val->residencyAlignedMipSize);
504     size += vn_sizeof_VkBool32(&val->residencyNonResidentStrict);
505     return size;
506 }
507 
508 static inline void
vn_decode_VkPhysicalDeviceSparseProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSparseProperties * val)509 vn_decode_VkPhysicalDeviceSparseProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSparseProperties *val)
510 {
511     vn_decode_VkBool32(dec, &val->residencyStandard2DBlockShape);
512     vn_decode_VkBool32(dec, &val->residencyStandard2DMultisampleBlockShape);
513     vn_decode_VkBool32(dec, &val->residencyStandard3DBlockShape);
514     vn_decode_VkBool32(dec, &val->residencyAlignedMipSize);
515     vn_decode_VkBool32(dec, &val->residencyNonResidentStrict);
516 }
517 
518 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseProperties_partial(const VkPhysicalDeviceSparseProperties * val)519 vn_sizeof_VkPhysicalDeviceSparseProperties_partial(const VkPhysicalDeviceSparseProperties *val)
520 {
521     size_t size = 0;
522     /* skip val->residencyStandard2DBlockShape */
523     /* skip val->residencyStandard2DMultisampleBlockShape */
524     /* skip val->residencyStandard3DBlockShape */
525     /* skip val->residencyAlignedMipSize */
526     /* skip val->residencyNonResidentStrict */
527     return size;
528 }
529 
530 static inline void
vn_encode_VkPhysicalDeviceSparseProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseProperties * val)531 vn_encode_VkPhysicalDeviceSparseProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseProperties *val)
532 {
533     /* skip val->residencyStandard2DBlockShape */
534     /* skip val->residencyStandard2DMultisampleBlockShape */
535     /* skip val->residencyStandard3DBlockShape */
536     /* skip val->residencyAlignedMipSize */
537     /* skip val->residencyNonResidentStrict */
538 }
539 
540 /* struct VkPhysicalDeviceProperties */
541 
542 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties * val)543 vn_sizeof_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties *val)
544 {
545     size_t size = 0;
546     size += vn_sizeof_uint32_t(&val->apiVersion);
547     size += vn_sizeof_uint32_t(&val->driverVersion);
548     size += vn_sizeof_uint32_t(&val->vendorID);
549     size += vn_sizeof_uint32_t(&val->deviceID);
550     size += vn_sizeof_VkPhysicalDeviceType(&val->deviceType);
551     size += vn_sizeof_array_size(VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
552     size += vn_sizeof_char_array(val->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
553     size += vn_sizeof_array_size(VK_UUID_SIZE);
554     size += vn_sizeof_uint8_t_array(val->pipelineCacheUUID, VK_UUID_SIZE);
555     size += vn_sizeof_VkPhysicalDeviceLimits(&val->limits);
556     size += vn_sizeof_VkPhysicalDeviceSparseProperties(&val->sparseProperties);
557     return size;
558 }
559 
560 static inline void
vn_decode_VkPhysicalDeviceProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties * val)561 vn_decode_VkPhysicalDeviceProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties *val)
562 {
563     vn_decode_uint32_t(dec, &val->apiVersion);
564     vn_decode_uint32_t(dec, &val->driverVersion);
565     vn_decode_uint32_t(dec, &val->vendorID);
566     vn_decode_uint32_t(dec, &val->deviceID);
567     vn_decode_VkPhysicalDeviceType(dec, &val->deviceType);
568     {
569         const size_t array_size = vn_decode_array_size(dec, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
570         vn_decode_char_array(dec, val->deviceName, array_size);
571     }
572     {
573         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
574         vn_decode_uint8_t_array(dec, val->pipelineCacheUUID, array_size);
575     }
576     vn_decode_VkPhysicalDeviceLimits(dec, &val->limits);
577     vn_decode_VkPhysicalDeviceSparseProperties(dec, &val->sparseProperties);
578 }
579 
580 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties_partial(const VkPhysicalDeviceProperties * val)581 vn_sizeof_VkPhysicalDeviceProperties_partial(const VkPhysicalDeviceProperties *val)
582 {
583     size_t size = 0;
584     /* skip val->apiVersion */
585     /* skip val->driverVersion */
586     /* skip val->vendorID */
587     /* skip val->deviceID */
588     /* skip val->deviceType */
589     /* skip val->deviceName */
590     /* skip val->pipelineCacheUUID */
591     size += vn_sizeof_VkPhysicalDeviceLimits_partial(&val->limits);
592     size += vn_sizeof_VkPhysicalDeviceSparseProperties_partial(&val->sparseProperties);
593     return size;
594 }
595 
596 static inline void
vn_encode_VkPhysicalDeviceProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties * val)597 vn_encode_VkPhysicalDeviceProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties *val)
598 {
599     /* skip val->apiVersion */
600     /* skip val->driverVersion */
601     /* skip val->vendorID */
602     /* skip val->deviceID */
603     /* skip val->deviceType */
604     /* skip val->deviceName */
605     /* skip val->pipelineCacheUUID */
606     vn_encode_VkPhysicalDeviceLimits_partial(enc, &val->limits);
607     vn_encode_VkPhysicalDeviceSparseProperties_partial(enc, &val->sparseProperties);
608 }
609 
610 /* struct VkQueueFamilyProperties */
611 
612 static inline size_t
vn_sizeof_VkQueueFamilyProperties(const VkQueueFamilyProperties * val)613 vn_sizeof_VkQueueFamilyProperties(const VkQueueFamilyProperties *val)
614 {
615     size_t size = 0;
616     size += vn_sizeof_VkFlags(&val->queueFlags);
617     size += vn_sizeof_uint32_t(&val->queueCount);
618     size += vn_sizeof_uint32_t(&val->timestampValidBits);
619     size += vn_sizeof_VkExtent3D(&val->minImageTransferGranularity);
620     return size;
621 }
622 
623 static inline void
vn_decode_VkQueueFamilyProperties(struct vn_cs_decoder * dec,VkQueueFamilyProperties * val)624 vn_decode_VkQueueFamilyProperties(struct vn_cs_decoder *dec, VkQueueFamilyProperties *val)
625 {
626     vn_decode_VkFlags(dec, &val->queueFlags);
627     vn_decode_uint32_t(dec, &val->queueCount);
628     vn_decode_uint32_t(dec, &val->timestampValidBits);
629     vn_decode_VkExtent3D(dec, &val->minImageTransferGranularity);
630 }
631 
632 static inline size_t
vn_sizeof_VkQueueFamilyProperties_partial(const VkQueueFamilyProperties * val)633 vn_sizeof_VkQueueFamilyProperties_partial(const VkQueueFamilyProperties *val)
634 {
635     size_t size = 0;
636     /* skip val->queueFlags */
637     /* skip val->queueCount */
638     /* skip val->timestampValidBits */
639     size += vn_sizeof_VkExtent3D_partial(&val->minImageTransferGranularity);
640     return size;
641 }
642 
643 static inline void
vn_encode_VkQueueFamilyProperties_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties * val)644 vn_encode_VkQueueFamilyProperties_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties *val)
645 {
646     /* skip val->queueFlags */
647     /* skip val->queueCount */
648     /* skip val->timestampValidBits */
649     vn_encode_VkExtent3D_partial(enc, &val->minImageTransferGranularity);
650 }
651 
652 /* struct VkMemoryType */
653 
654 static inline size_t
vn_sizeof_VkMemoryType(const VkMemoryType * val)655 vn_sizeof_VkMemoryType(const VkMemoryType *val)
656 {
657     size_t size = 0;
658     size += vn_sizeof_VkFlags(&val->propertyFlags);
659     size += vn_sizeof_uint32_t(&val->heapIndex);
660     return size;
661 }
662 
663 static inline void
vn_decode_VkMemoryType(struct vn_cs_decoder * dec,VkMemoryType * val)664 vn_decode_VkMemoryType(struct vn_cs_decoder *dec, VkMemoryType *val)
665 {
666     vn_decode_VkFlags(dec, &val->propertyFlags);
667     vn_decode_uint32_t(dec, &val->heapIndex);
668 }
669 
670 static inline size_t
vn_sizeof_VkMemoryType_partial(const VkMemoryType * val)671 vn_sizeof_VkMemoryType_partial(const VkMemoryType *val)
672 {
673     size_t size = 0;
674     /* skip val->propertyFlags */
675     /* skip val->heapIndex */
676     return size;
677 }
678 
679 static inline void
vn_encode_VkMemoryType_partial(struct vn_cs_encoder * enc,const VkMemoryType * val)680 vn_encode_VkMemoryType_partial(struct vn_cs_encoder *enc, const VkMemoryType *val)
681 {
682     /* skip val->propertyFlags */
683     /* skip val->heapIndex */
684 }
685 
686 /* struct VkMemoryHeap */
687 
688 static inline size_t
vn_sizeof_VkMemoryHeap(const VkMemoryHeap * val)689 vn_sizeof_VkMemoryHeap(const VkMemoryHeap *val)
690 {
691     size_t size = 0;
692     size += vn_sizeof_VkDeviceSize(&val->size);
693     size += vn_sizeof_VkFlags(&val->flags);
694     return size;
695 }
696 
697 static inline void
vn_decode_VkMemoryHeap(struct vn_cs_decoder * dec,VkMemoryHeap * val)698 vn_decode_VkMemoryHeap(struct vn_cs_decoder *dec, VkMemoryHeap *val)
699 {
700     vn_decode_VkDeviceSize(dec, &val->size);
701     vn_decode_VkFlags(dec, &val->flags);
702 }
703 
704 static inline size_t
vn_sizeof_VkMemoryHeap_partial(const VkMemoryHeap * val)705 vn_sizeof_VkMemoryHeap_partial(const VkMemoryHeap *val)
706 {
707     size_t size = 0;
708     /* skip val->size */
709     /* skip val->flags */
710     return size;
711 }
712 
713 static inline void
vn_encode_VkMemoryHeap_partial(struct vn_cs_encoder * enc,const VkMemoryHeap * val)714 vn_encode_VkMemoryHeap_partial(struct vn_cs_encoder *enc, const VkMemoryHeap *val)
715 {
716     /* skip val->size */
717     /* skip val->flags */
718 }
719 
720 /* struct VkPhysicalDeviceMemoryProperties */
721 
722 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties * val)723 vn_sizeof_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties *val)
724 {
725     size_t size = 0;
726     size += vn_sizeof_uint32_t(&val->memoryTypeCount);
727     size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
728     for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
729         size += vn_sizeof_VkMemoryType(&val->memoryTypes[i]);
730     size += vn_sizeof_uint32_t(&val->memoryHeapCount);
731     size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
732     for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
733         size += vn_sizeof_VkMemoryHeap(&val->memoryHeaps[i]);
734     return size;
735 }
736 
737 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties * val)738 vn_decode_VkPhysicalDeviceMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties *val)
739 {
740     vn_decode_uint32_t(dec, &val->memoryTypeCount);
741     {
742         const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_MEMORY_TYPES);
743         for (uint32_t i = 0; i < iter_count; i++)
744             vn_decode_VkMemoryType(dec, &val->memoryTypes[i]);
745     }
746     vn_decode_uint32_t(dec, &val->memoryHeapCount);
747     {
748         const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_MEMORY_HEAPS);
749         for (uint32_t i = 0; i < iter_count; i++)
750             vn_decode_VkMemoryHeap(dec, &val->memoryHeaps[i]);
751     }
752 }
753 
754 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(const VkPhysicalDeviceMemoryProperties * val)755 vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(const VkPhysicalDeviceMemoryProperties *val)
756 {
757     size_t size = 0;
758     /* skip val->memoryTypeCount */
759     size += vn_sizeof_array_size(VK_MAX_MEMORY_TYPES);
760     for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
761         size += vn_sizeof_VkMemoryType_partial(&val->memoryTypes[i]);
762     /* skip val->memoryHeapCount */
763     size += vn_sizeof_array_size(VK_MAX_MEMORY_HEAPS);
764     for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
765         size += vn_sizeof_VkMemoryHeap_partial(&val->memoryHeaps[i]);
766     return size;
767 }
768 
769 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties * val)770 vn_encode_VkPhysicalDeviceMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties *val)
771 {
772     /* skip val->memoryTypeCount */
773     vn_encode_array_size(enc, VK_MAX_MEMORY_TYPES);
774     for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
775         vn_encode_VkMemoryType_partial(enc, &val->memoryTypes[i]);
776     /* skip val->memoryHeapCount */
777     vn_encode_array_size(enc, VK_MAX_MEMORY_HEAPS);
778     for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++)
779         vn_encode_VkMemoryHeap_partial(enc, &val->memoryHeaps[i]);
780 }
781 
782 /* struct VkPhysicalDeviceFeatures */
783 
784 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures * val)785 vn_sizeof_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures *val)
786 {
787     size_t size = 0;
788     size += vn_sizeof_VkBool32(&val->robustBufferAccess);
789     size += vn_sizeof_VkBool32(&val->fullDrawIndexUint32);
790     size += vn_sizeof_VkBool32(&val->imageCubeArray);
791     size += vn_sizeof_VkBool32(&val->independentBlend);
792     size += vn_sizeof_VkBool32(&val->geometryShader);
793     size += vn_sizeof_VkBool32(&val->tessellationShader);
794     size += vn_sizeof_VkBool32(&val->sampleRateShading);
795     size += vn_sizeof_VkBool32(&val->dualSrcBlend);
796     size += vn_sizeof_VkBool32(&val->logicOp);
797     size += vn_sizeof_VkBool32(&val->multiDrawIndirect);
798     size += vn_sizeof_VkBool32(&val->drawIndirectFirstInstance);
799     size += vn_sizeof_VkBool32(&val->depthClamp);
800     size += vn_sizeof_VkBool32(&val->depthBiasClamp);
801     size += vn_sizeof_VkBool32(&val->fillModeNonSolid);
802     size += vn_sizeof_VkBool32(&val->depthBounds);
803     size += vn_sizeof_VkBool32(&val->wideLines);
804     size += vn_sizeof_VkBool32(&val->largePoints);
805     size += vn_sizeof_VkBool32(&val->alphaToOne);
806     size += vn_sizeof_VkBool32(&val->multiViewport);
807     size += vn_sizeof_VkBool32(&val->samplerAnisotropy);
808     size += vn_sizeof_VkBool32(&val->textureCompressionETC2);
809     size += vn_sizeof_VkBool32(&val->textureCompressionASTC_LDR);
810     size += vn_sizeof_VkBool32(&val->textureCompressionBC);
811     size += vn_sizeof_VkBool32(&val->occlusionQueryPrecise);
812     size += vn_sizeof_VkBool32(&val->pipelineStatisticsQuery);
813     size += vn_sizeof_VkBool32(&val->vertexPipelineStoresAndAtomics);
814     size += vn_sizeof_VkBool32(&val->fragmentStoresAndAtomics);
815     size += vn_sizeof_VkBool32(&val->shaderTessellationAndGeometryPointSize);
816     size += vn_sizeof_VkBool32(&val->shaderImageGatherExtended);
817     size += vn_sizeof_VkBool32(&val->shaderStorageImageExtendedFormats);
818     size += vn_sizeof_VkBool32(&val->shaderStorageImageMultisample);
819     size += vn_sizeof_VkBool32(&val->shaderStorageImageReadWithoutFormat);
820     size += vn_sizeof_VkBool32(&val->shaderStorageImageWriteWithoutFormat);
821     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayDynamicIndexing);
822     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayDynamicIndexing);
823     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayDynamicIndexing);
824     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayDynamicIndexing);
825     size += vn_sizeof_VkBool32(&val->shaderClipDistance);
826     size += vn_sizeof_VkBool32(&val->shaderCullDistance);
827     size += vn_sizeof_VkBool32(&val->shaderFloat64);
828     size += vn_sizeof_VkBool32(&val->shaderInt64);
829     size += vn_sizeof_VkBool32(&val->shaderInt16);
830     size += vn_sizeof_VkBool32(&val->shaderResourceResidency);
831     size += vn_sizeof_VkBool32(&val->shaderResourceMinLod);
832     size += vn_sizeof_VkBool32(&val->sparseBinding);
833     size += vn_sizeof_VkBool32(&val->sparseResidencyBuffer);
834     size += vn_sizeof_VkBool32(&val->sparseResidencyImage2D);
835     size += vn_sizeof_VkBool32(&val->sparseResidencyImage3D);
836     size += vn_sizeof_VkBool32(&val->sparseResidency2Samples);
837     size += vn_sizeof_VkBool32(&val->sparseResidency4Samples);
838     size += vn_sizeof_VkBool32(&val->sparseResidency8Samples);
839     size += vn_sizeof_VkBool32(&val->sparseResidency16Samples);
840     size += vn_sizeof_VkBool32(&val->sparseResidencyAliased);
841     size += vn_sizeof_VkBool32(&val->variableMultisampleRate);
842     size += vn_sizeof_VkBool32(&val->inheritedQueries);
843     return size;
844 }
845 
846 static inline void
vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures * val)847 vn_encode_VkPhysicalDeviceFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
848 {
849     vn_encode_VkBool32(enc, &val->robustBufferAccess);
850     vn_encode_VkBool32(enc, &val->fullDrawIndexUint32);
851     vn_encode_VkBool32(enc, &val->imageCubeArray);
852     vn_encode_VkBool32(enc, &val->independentBlend);
853     vn_encode_VkBool32(enc, &val->geometryShader);
854     vn_encode_VkBool32(enc, &val->tessellationShader);
855     vn_encode_VkBool32(enc, &val->sampleRateShading);
856     vn_encode_VkBool32(enc, &val->dualSrcBlend);
857     vn_encode_VkBool32(enc, &val->logicOp);
858     vn_encode_VkBool32(enc, &val->multiDrawIndirect);
859     vn_encode_VkBool32(enc, &val->drawIndirectFirstInstance);
860     vn_encode_VkBool32(enc, &val->depthClamp);
861     vn_encode_VkBool32(enc, &val->depthBiasClamp);
862     vn_encode_VkBool32(enc, &val->fillModeNonSolid);
863     vn_encode_VkBool32(enc, &val->depthBounds);
864     vn_encode_VkBool32(enc, &val->wideLines);
865     vn_encode_VkBool32(enc, &val->largePoints);
866     vn_encode_VkBool32(enc, &val->alphaToOne);
867     vn_encode_VkBool32(enc, &val->multiViewport);
868     vn_encode_VkBool32(enc, &val->samplerAnisotropy);
869     vn_encode_VkBool32(enc, &val->textureCompressionETC2);
870     vn_encode_VkBool32(enc, &val->textureCompressionASTC_LDR);
871     vn_encode_VkBool32(enc, &val->textureCompressionBC);
872     vn_encode_VkBool32(enc, &val->occlusionQueryPrecise);
873     vn_encode_VkBool32(enc, &val->pipelineStatisticsQuery);
874     vn_encode_VkBool32(enc, &val->vertexPipelineStoresAndAtomics);
875     vn_encode_VkBool32(enc, &val->fragmentStoresAndAtomics);
876     vn_encode_VkBool32(enc, &val->shaderTessellationAndGeometryPointSize);
877     vn_encode_VkBool32(enc, &val->shaderImageGatherExtended);
878     vn_encode_VkBool32(enc, &val->shaderStorageImageExtendedFormats);
879     vn_encode_VkBool32(enc, &val->shaderStorageImageMultisample);
880     vn_encode_VkBool32(enc, &val->shaderStorageImageReadWithoutFormat);
881     vn_encode_VkBool32(enc, &val->shaderStorageImageWriteWithoutFormat);
882     vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayDynamicIndexing);
883     vn_encode_VkBool32(enc, &val->shaderSampledImageArrayDynamicIndexing);
884     vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayDynamicIndexing);
885     vn_encode_VkBool32(enc, &val->shaderStorageImageArrayDynamicIndexing);
886     vn_encode_VkBool32(enc, &val->shaderClipDistance);
887     vn_encode_VkBool32(enc, &val->shaderCullDistance);
888     vn_encode_VkBool32(enc, &val->shaderFloat64);
889     vn_encode_VkBool32(enc, &val->shaderInt64);
890     vn_encode_VkBool32(enc, &val->shaderInt16);
891     vn_encode_VkBool32(enc, &val->shaderResourceResidency);
892     vn_encode_VkBool32(enc, &val->shaderResourceMinLod);
893     vn_encode_VkBool32(enc, &val->sparseBinding);
894     vn_encode_VkBool32(enc, &val->sparseResidencyBuffer);
895     vn_encode_VkBool32(enc, &val->sparseResidencyImage2D);
896     vn_encode_VkBool32(enc, &val->sparseResidencyImage3D);
897     vn_encode_VkBool32(enc, &val->sparseResidency2Samples);
898     vn_encode_VkBool32(enc, &val->sparseResidency4Samples);
899     vn_encode_VkBool32(enc, &val->sparseResidency8Samples);
900     vn_encode_VkBool32(enc, &val->sparseResidency16Samples);
901     vn_encode_VkBool32(enc, &val->sparseResidencyAliased);
902     vn_encode_VkBool32(enc, &val->variableMultisampleRate);
903     vn_encode_VkBool32(enc, &val->inheritedQueries);
904 }
905 
906 static inline void
vn_decode_VkPhysicalDeviceFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures * val)907 vn_decode_VkPhysicalDeviceFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures *val)
908 {
909     vn_decode_VkBool32(dec, &val->robustBufferAccess);
910     vn_decode_VkBool32(dec, &val->fullDrawIndexUint32);
911     vn_decode_VkBool32(dec, &val->imageCubeArray);
912     vn_decode_VkBool32(dec, &val->independentBlend);
913     vn_decode_VkBool32(dec, &val->geometryShader);
914     vn_decode_VkBool32(dec, &val->tessellationShader);
915     vn_decode_VkBool32(dec, &val->sampleRateShading);
916     vn_decode_VkBool32(dec, &val->dualSrcBlend);
917     vn_decode_VkBool32(dec, &val->logicOp);
918     vn_decode_VkBool32(dec, &val->multiDrawIndirect);
919     vn_decode_VkBool32(dec, &val->drawIndirectFirstInstance);
920     vn_decode_VkBool32(dec, &val->depthClamp);
921     vn_decode_VkBool32(dec, &val->depthBiasClamp);
922     vn_decode_VkBool32(dec, &val->fillModeNonSolid);
923     vn_decode_VkBool32(dec, &val->depthBounds);
924     vn_decode_VkBool32(dec, &val->wideLines);
925     vn_decode_VkBool32(dec, &val->largePoints);
926     vn_decode_VkBool32(dec, &val->alphaToOne);
927     vn_decode_VkBool32(dec, &val->multiViewport);
928     vn_decode_VkBool32(dec, &val->samplerAnisotropy);
929     vn_decode_VkBool32(dec, &val->textureCompressionETC2);
930     vn_decode_VkBool32(dec, &val->textureCompressionASTC_LDR);
931     vn_decode_VkBool32(dec, &val->textureCompressionBC);
932     vn_decode_VkBool32(dec, &val->occlusionQueryPrecise);
933     vn_decode_VkBool32(dec, &val->pipelineStatisticsQuery);
934     vn_decode_VkBool32(dec, &val->vertexPipelineStoresAndAtomics);
935     vn_decode_VkBool32(dec, &val->fragmentStoresAndAtomics);
936     vn_decode_VkBool32(dec, &val->shaderTessellationAndGeometryPointSize);
937     vn_decode_VkBool32(dec, &val->shaderImageGatherExtended);
938     vn_decode_VkBool32(dec, &val->shaderStorageImageExtendedFormats);
939     vn_decode_VkBool32(dec, &val->shaderStorageImageMultisample);
940     vn_decode_VkBool32(dec, &val->shaderStorageImageReadWithoutFormat);
941     vn_decode_VkBool32(dec, &val->shaderStorageImageWriteWithoutFormat);
942     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayDynamicIndexing);
943     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayDynamicIndexing);
944     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayDynamicIndexing);
945     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayDynamicIndexing);
946     vn_decode_VkBool32(dec, &val->shaderClipDistance);
947     vn_decode_VkBool32(dec, &val->shaderCullDistance);
948     vn_decode_VkBool32(dec, &val->shaderFloat64);
949     vn_decode_VkBool32(dec, &val->shaderInt64);
950     vn_decode_VkBool32(dec, &val->shaderInt16);
951     vn_decode_VkBool32(dec, &val->shaderResourceResidency);
952     vn_decode_VkBool32(dec, &val->shaderResourceMinLod);
953     vn_decode_VkBool32(dec, &val->sparseBinding);
954     vn_decode_VkBool32(dec, &val->sparseResidencyBuffer);
955     vn_decode_VkBool32(dec, &val->sparseResidencyImage2D);
956     vn_decode_VkBool32(dec, &val->sparseResidencyImage3D);
957     vn_decode_VkBool32(dec, &val->sparseResidency2Samples);
958     vn_decode_VkBool32(dec, &val->sparseResidency4Samples);
959     vn_decode_VkBool32(dec, &val->sparseResidency8Samples);
960     vn_decode_VkBool32(dec, &val->sparseResidency16Samples);
961     vn_decode_VkBool32(dec, &val->sparseResidencyAliased);
962     vn_decode_VkBool32(dec, &val->variableMultisampleRate);
963     vn_decode_VkBool32(dec, &val->inheritedQueries);
964 }
965 
966 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures_partial(const VkPhysicalDeviceFeatures * val)967 vn_sizeof_VkPhysicalDeviceFeatures_partial(const VkPhysicalDeviceFeatures *val)
968 {
969     size_t size = 0;
970     /* skip val->robustBufferAccess */
971     /* skip val->fullDrawIndexUint32 */
972     /* skip val->imageCubeArray */
973     /* skip val->independentBlend */
974     /* skip val->geometryShader */
975     /* skip val->tessellationShader */
976     /* skip val->sampleRateShading */
977     /* skip val->dualSrcBlend */
978     /* skip val->logicOp */
979     /* skip val->multiDrawIndirect */
980     /* skip val->drawIndirectFirstInstance */
981     /* skip val->depthClamp */
982     /* skip val->depthBiasClamp */
983     /* skip val->fillModeNonSolid */
984     /* skip val->depthBounds */
985     /* skip val->wideLines */
986     /* skip val->largePoints */
987     /* skip val->alphaToOne */
988     /* skip val->multiViewport */
989     /* skip val->samplerAnisotropy */
990     /* skip val->textureCompressionETC2 */
991     /* skip val->textureCompressionASTC_LDR */
992     /* skip val->textureCompressionBC */
993     /* skip val->occlusionQueryPrecise */
994     /* skip val->pipelineStatisticsQuery */
995     /* skip val->vertexPipelineStoresAndAtomics */
996     /* skip val->fragmentStoresAndAtomics */
997     /* skip val->shaderTessellationAndGeometryPointSize */
998     /* skip val->shaderImageGatherExtended */
999     /* skip val->shaderStorageImageExtendedFormats */
1000     /* skip val->shaderStorageImageMultisample */
1001     /* skip val->shaderStorageImageReadWithoutFormat */
1002     /* skip val->shaderStorageImageWriteWithoutFormat */
1003     /* skip val->shaderUniformBufferArrayDynamicIndexing */
1004     /* skip val->shaderSampledImageArrayDynamicIndexing */
1005     /* skip val->shaderStorageBufferArrayDynamicIndexing */
1006     /* skip val->shaderStorageImageArrayDynamicIndexing */
1007     /* skip val->shaderClipDistance */
1008     /* skip val->shaderCullDistance */
1009     /* skip val->shaderFloat64 */
1010     /* skip val->shaderInt64 */
1011     /* skip val->shaderInt16 */
1012     /* skip val->shaderResourceResidency */
1013     /* skip val->shaderResourceMinLod */
1014     /* skip val->sparseBinding */
1015     /* skip val->sparseResidencyBuffer */
1016     /* skip val->sparseResidencyImage2D */
1017     /* skip val->sparseResidencyImage3D */
1018     /* skip val->sparseResidency2Samples */
1019     /* skip val->sparseResidency4Samples */
1020     /* skip val->sparseResidency8Samples */
1021     /* skip val->sparseResidency16Samples */
1022     /* skip val->sparseResidencyAliased */
1023     /* skip val->variableMultisampleRate */
1024     /* skip val->inheritedQueries */
1025     return size;
1026 }
1027 
1028 static inline void
vn_encode_VkPhysicalDeviceFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures * val)1029 vn_encode_VkPhysicalDeviceFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures *val)
1030 {
1031     /* skip val->robustBufferAccess */
1032     /* skip val->fullDrawIndexUint32 */
1033     /* skip val->imageCubeArray */
1034     /* skip val->independentBlend */
1035     /* skip val->geometryShader */
1036     /* skip val->tessellationShader */
1037     /* skip val->sampleRateShading */
1038     /* skip val->dualSrcBlend */
1039     /* skip val->logicOp */
1040     /* skip val->multiDrawIndirect */
1041     /* skip val->drawIndirectFirstInstance */
1042     /* skip val->depthClamp */
1043     /* skip val->depthBiasClamp */
1044     /* skip val->fillModeNonSolid */
1045     /* skip val->depthBounds */
1046     /* skip val->wideLines */
1047     /* skip val->largePoints */
1048     /* skip val->alphaToOne */
1049     /* skip val->multiViewport */
1050     /* skip val->samplerAnisotropy */
1051     /* skip val->textureCompressionETC2 */
1052     /* skip val->textureCompressionASTC_LDR */
1053     /* skip val->textureCompressionBC */
1054     /* skip val->occlusionQueryPrecise */
1055     /* skip val->pipelineStatisticsQuery */
1056     /* skip val->vertexPipelineStoresAndAtomics */
1057     /* skip val->fragmentStoresAndAtomics */
1058     /* skip val->shaderTessellationAndGeometryPointSize */
1059     /* skip val->shaderImageGatherExtended */
1060     /* skip val->shaderStorageImageExtendedFormats */
1061     /* skip val->shaderStorageImageMultisample */
1062     /* skip val->shaderStorageImageReadWithoutFormat */
1063     /* skip val->shaderStorageImageWriteWithoutFormat */
1064     /* skip val->shaderUniformBufferArrayDynamicIndexing */
1065     /* skip val->shaderSampledImageArrayDynamicIndexing */
1066     /* skip val->shaderStorageBufferArrayDynamicIndexing */
1067     /* skip val->shaderStorageImageArrayDynamicIndexing */
1068     /* skip val->shaderClipDistance */
1069     /* skip val->shaderCullDistance */
1070     /* skip val->shaderFloat64 */
1071     /* skip val->shaderInt64 */
1072     /* skip val->shaderInt16 */
1073     /* skip val->shaderResourceResidency */
1074     /* skip val->shaderResourceMinLod */
1075     /* skip val->sparseBinding */
1076     /* skip val->sparseResidencyBuffer */
1077     /* skip val->sparseResidencyImage2D */
1078     /* skip val->sparseResidencyImage3D */
1079     /* skip val->sparseResidency2Samples */
1080     /* skip val->sparseResidency4Samples */
1081     /* skip val->sparseResidency8Samples */
1082     /* skip val->sparseResidency16Samples */
1083     /* skip val->sparseResidencyAliased */
1084     /* skip val->variableMultisampleRate */
1085     /* skip val->inheritedQueries */
1086 }
1087 
1088 /* struct VkFormatProperties */
1089 
1090 static inline size_t
vn_sizeof_VkFormatProperties(const VkFormatProperties * val)1091 vn_sizeof_VkFormatProperties(const VkFormatProperties *val)
1092 {
1093     size_t size = 0;
1094     size += vn_sizeof_VkFlags(&val->linearTilingFeatures);
1095     size += vn_sizeof_VkFlags(&val->optimalTilingFeatures);
1096     size += vn_sizeof_VkFlags(&val->bufferFeatures);
1097     return size;
1098 }
1099 
1100 static inline void
vn_decode_VkFormatProperties(struct vn_cs_decoder * dec,VkFormatProperties * val)1101 vn_decode_VkFormatProperties(struct vn_cs_decoder *dec, VkFormatProperties *val)
1102 {
1103     vn_decode_VkFlags(dec, &val->linearTilingFeatures);
1104     vn_decode_VkFlags(dec, &val->optimalTilingFeatures);
1105     vn_decode_VkFlags(dec, &val->bufferFeatures);
1106 }
1107 
1108 static inline size_t
vn_sizeof_VkFormatProperties_partial(const VkFormatProperties * val)1109 vn_sizeof_VkFormatProperties_partial(const VkFormatProperties *val)
1110 {
1111     size_t size = 0;
1112     /* skip val->linearTilingFeatures */
1113     /* skip val->optimalTilingFeatures */
1114     /* skip val->bufferFeatures */
1115     return size;
1116 }
1117 
1118 static inline void
vn_encode_VkFormatProperties_partial(struct vn_cs_encoder * enc,const VkFormatProperties * val)1119 vn_encode_VkFormatProperties_partial(struct vn_cs_encoder *enc, const VkFormatProperties *val)
1120 {
1121     /* skip val->linearTilingFeatures */
1122     /* skip val->optimalTilingFeatures */
1123     /* skip val->bufferFeatures */
1124 }
1125 
1126 /* struct VkImageFormatProperties */
1127 
1128 static inline size_t
vn_sizeof_VkImageFormatProperties(const VkImageFormatProperties * val)1129 vn_sizeof_VkImageFormatProperties(const VkImageFormatProperties *val)
1130 {
1131     size_t size = 0;
1132     size += vn_sizeof_VkExtent3D(&val->maxExtent);
1133     size += vn_sizeof_uint32_t(&val->maxMipLevels);
1134     size += vn_sizeof_uint32_t(&val->maxArrayLayers);
1135     size += vn_sizeof_VkFlags(&val->sampleCounts);
1136     size += vn_sizeof_VkDeviceSize(&val->maxResourceSize);
1137     return size;
1138 }
1139 
1140 static inline void
vn_decode_VkImageFormatProperties(struct vn_cs_decoder * dec,VkImageFormatProperties * val)1141 vn_decode_VkImageFormatProperties(struct vn_cs_decoder *dec, VkImageFormatProperties *val)
1142 {
1143     vn_decode_VkExtent3D(dec, &val->maxExtent);
1144     vn_decode_uint32_t(dec, &val->maxMipLevels);
1145     vn_decode_uint32_t(dec, &val->maxArrayLayers);
1146     vn_decode_VkFlags(dec, &val->sampleCounts);
1147     vn_decode_VkDeviceSize(dec, &val->maxResourceSize);
1148 }
1149 
1150 static inline size_t
vn_sizeof_VkImageFormatProperties_partial(const VkImageFormatProperties * val)1151 vn_sizeof_VkImageFormatProperties_partial(const VkImageFormatProperties *val)
1152 {
1153     size_t size = 0;
1154     size += vn_sizeof_VkExtent3D_partial(&val->maxExtent);
1155     /* skip val->maxMipLevels */
1156     /* skip val->maxArrayLayers */
1157     /* skip val->sampleCounts */
1158     /* skip val->maxResourceSize */
1159     return size;
1160 }
1161 
1162 static inline void
vn_encode_VkImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties * val)1163 vn_encode_VkImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties *val)
1164 {
1165     vn_encode_VkExtent3D_partial(enc, &val->maxExtent);
1166     /* skip val->maxMipLevels */
1167     /* skip val->maxArrayLayers */
1168     /* skip val->sampleCounts */
1169     /* skip val->maxResourceSize */
1170 }
1171 
1172 /* struct VkDeviceQueueCreateInfo chain */
1173 
1174 static inline size_t
vn_sizeof_VkDeviceQueueCreateInfo_pnext(const void * val)1175 vn_sizeof_VkDeviceQueueCreateInfo_pnext(const void *val)
1176 {
1177     /* no known/supported struct */
1178     return vn_sizeof_simple_pointer(NULL);
1179 }
1180 
1181 static inline size_t
vn_sizeof_VkDeviceQueueCreateInfo_self(const VkDeviceQueueCreateInfo * val)1182 vn_sizeof_VkDeviceQueueCreateInfo_self(const VkDeviceQueueCreateInfo *val)
1183 {
1184     size_t size = 0;
1185     /* skip val->{sType,pNext} */
1186     size += vn_sizeof_VkFlags(&val->flags);
1187     size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
1188     size += vn_sizeof_uint32_t(&val->queueCount);
1189     if (val->pQueuePriorities) {
1190         size += vn_sizeof_array_size(val->queueCount);
1191         size += vn_sizeof_float_array(val->pQueuePriorities, val->queueCount);
1192     } else {
1193         size += vn_sizeof_array_size(0);
1194     }
1195     return size;
1196 }
1197 
1198 static inline size_t
vn_sizeof_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo * val)1199 vn_sizeof_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo *val)
1200 {
1201     size_t size = 0;
1202 
1203     size += vn_sizeof_VkStructureType(&val->sType);
1204     size += vn_sizeof_VkDeviceQueueCreateInfo_pnext(val->pNext);
1205     size += vn_sizeof_VkDeviceQueueCreateInfo_self(val);
1206 
1207     return size;
1208 }
1209 
1210 static inline void
vn_encode_VkDeviceQueueCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1211 vn_encode_VkDeviceQueueCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1212 {
1213     /* no known/supported struct */
1214     vn_encode_simple_pointer(enc, NULL);
1215 }
1216 
1217 static inline void
vn_encode_VkDeviceQueueCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceQueueCreateInfo * val)1218 vn_encode_VkDeviceQueueCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
1219 {
1220     /* skip val->{sType,pNext} */
1221     vn_encode_VkFlags(enc, &val->flags);
1222     vn_encode_uint32_t(enc, &val->queueFamilyIndex);
1223     vn_encode_uint32_t(enc, &val->queueCount);
1224     if (val->pQueuePriorities) {
1225         vn_encode_array_size(enc, val->queueCount);
1226         vn_encode_float_array(enc, val->pQueuePriorities, val->queueCount);
1227     } else {
1228         vn_encode_array_size(enc, 0);
1229     }
1230 }
1231 
1232 static inline void
vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder * enc,const VkDeviceQueueCreateInfo * val)1233 vn_encode_VkDeviceQueueCreateInfo(struct vn_cs_encoder *enc, const VkDeviceQueueCreateInfo *val)
1234 {
1235     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO);
1236     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO });
1237     vn_encode_VkDeviceQueueCreateInfo_pnext(enc, val->pNext);
1238     vn_encode_VkDeviceQueueCreateInfo_self(enc, val);
1239 }
1240 
1241 /* struct VkPhysicalDeviceVariablePointersFeatures chain */
1242 
1243 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void * val)1244 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void *val)
1245 {
1246     /* no known/supported struct */
1247     return vn_sizeof_simple_pointer(NULL);
1248 }
1249 
1250 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures * val)1251 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures *val)
1252 {
1253     size_t size = 0;
1254     /* skip val->{sType,pNext} */
1255     size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
1256     size += vn_sizeof_VkBool32(&val->variablePointers);
1257     return size;
1258 }
1259 
1260 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures * val)1261 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures *val)
1262 {
1263     size_t size = 0;
1264 
1265     size += vn_sizeof_VkStructureType(&val->sType);
1266     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(val->pNext);
1267     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(val);
1268 
1269     return size;
1270 }
1271 
1272 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1273 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1274 {
1275     /* no known/supported struct */
1276     vn_encode_simple_pointer(enc, NULL);
1277 }
1278 
1279 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1280 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1281 {
1282     /* skip val->{sType,pNext} */
1283     vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
1284     vn_encode_VkBool32(enc, &val->variablePointers);
1285 }
1286 
1287 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1288 vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1289 {
1290     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1291     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
1292     vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(enc, val->pNext);
1293     vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, val);
1294 }
1295 
1296 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1297 vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1298 {
1299     /* no known/supported struct */
1300     if (vn_decode_simple_pointer(dec))
1301         assert(false);
1302 }
1303 
1304 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)1305 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
1306 {
1307     /* skip val->{sType,pNext} */
1308     vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
1309     vn_decode_VkBool32(dec, &val->variablePointers);
1310 }
1311 
1312 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)1313 vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
1314 {
1315     VkStructureType stype;
1316     vn_decode_VkStructureType(dec, &stype);
1317     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1318 
1319     assert(val->sType == stype);
1320     vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(dec, val->pNext);
1321     vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, val);
1322 }
1323 
1324 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void * val)1325 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void *val)
1326 {
1327     /* no known/supported struct */
1328     return vn_sizeof_simple_pointer(NULL);
1329 }
1330 
1331 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures * val)1332 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
1333 {
1334     size_t size = 0;
1335     /* skip val->{sType,pNext} */
1336     /* skip val->variablePointersStorageBuffer */
1337     /* skip val->variablePointers */
1338     return size;
1339 }
1340 
1341 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures * val)1342 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
1343 {
1344     size_t size = 0;
1345 
1346     size += vn_sizeof_VkStructureType(&val->sType);
1347     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(val->pNext);
1348     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(val);
1349 
1350     return size;
1351 }
1352 
1353 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1354 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1355 {
1356     /* no known/supported struct */
1357     vn_encode_simple_pointer(enc, NULL);
1358 }
1359 
1360 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1361 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1362 {
1363     /* skip val->{sType,pNext} */
1364     /* skip val->variablePointersStorageBuffer */
1365     /* skip val->variablePointers */
1366 }
1367 
1368 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1369 vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1370 {
1371     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1372     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
1373     vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(enc, val->pNext);
1374     vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, val);
1375 }
1376 
1377 /* struct VkPhysicalDeviceMultiviewFeatures chain */
1378 
1379 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void * val)1380 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void *val)
1381 {
1382     /* no known/supported struct */
1383     return vn_sizeof_simple_pointer(NULL);
1384 }
1385 
1386 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures * val)1387 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures *val)
1388 {
1389     size_t size = 0;
1390     /* skip val->{sType,pNext} */
1391     size += vn_sizeof_VkBool32(&val->multiview);
1392     size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
1393     size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
1394     return size;
1395 }
1396 
1397 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures * val)1398 vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures *val)
1399 {
1400     size_t size = 0;
1401 
1402     size += vn_sizeof_VkStructureType(&val->sType);
1403     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(val->pNext);
1404     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(val);
1405 
1406     return size;
1407 }
1408 
1409 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1410 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1411 {
1412     /* no known/supported struct */
1413     vn_encode_simple_pointer(enc, NULL);
1414 }
1415 
1416 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1417 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1418 {
1419     /* skip val->{sType,pNext} */
1420     vn_encode_VkBool32(enc, &val->multiview);
1421     vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
1422     vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
1423 }
1424 
1425 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1426 vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1427 {
1428     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1429     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
1430     vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(enc, val->pNext);
1431     vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, val);
1432 }
1433 
1434 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1435 vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1436 {
1437     /* no known/supported struct */
1438     if (vn_decode_simple_pointer(dec))
1439         assert(false);
1440 }
1441 
1442 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)1443 vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
1444 {
1445     /* skip val->{sType,pNext} */
1446     vn_decode_VkBool32(dec, &val->multiview);
1447     vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
1448     vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
1449 }
1450 
1451 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)1452 vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
1453 {
1454     VkStructureType stype;
1455     vn_decode_VkStructureType(dec, &stype);
1456     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1457 
1458     assert(val->sType == stype);
1459     vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(dec, val->pNext);
1460     vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, val);
1461 }
1462 
1463 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void * val)1464 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void *val)
1465 {
1466     /* no known/supported struct */
1467     return vn_sizeof_simple_pointer(NULL);
1468 }
1469 
1470 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures * val)1471 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures *val)
1472 {
1473     size_t size = 0;
1474     /* skip val->{sType,pNext} */
1475     /* skip val->multiview */
1476     /* skip val->multiviewGeometryShader */
1477     /* skip val->multiviewTessellationShader */
1478     return size;
1479 }
1480 
1481 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures * val)1482 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures *val)
1483 {
1484     size_t size = 0;
1485 
1486     size += vn_sizeof_VkStructureType(&val->sType);
1487     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(val->pNext);
1488     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(val);
1489 
1490     return size;
1491 }
1492 
1493 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1494 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1495 {
1496     /* no known/supported struct */
1497     vn_encode_simple_pointer(enc, NULL);
1498 }
1499 
1500 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1501 vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1502 {
1503     /* skip val->{sType,pNext} */
1504     /* skip val->multiview */
1505     /* skip val->multiviewGeometryShader */
1506     /* skip val->multiviewTessellationShader */
1507 }
1508 
1509 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1510 vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1511 {
1512     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1513     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
1514     vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(enc, val->pNext);
1515     vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, val);
1516 }
1517 
1518 /* struct VkPhysicalDevice16BitStorageFeatures chain */
1519 
1520 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void * val)1521 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void *val)
1522 {
1523     /* no known/supported struct */
1524     return vn_sizeof_simple_pointer(NULL);
1525 }
1526 
1527 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures * val)1528 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures *val)
1529 {
1530     size_t size = 0;
1531     /* skip val->{sType,pNext} */
1532     size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
1533     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
1534     size += vn_sizeof_VkBool32(&val->storagePushConstant16);
1535     size += vn_sizeof_VkBool32(&val->storageInputOutput16);
1536     return size;
1537 }
1538 
1539 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures * val)1540 vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures *val)
1541 {
1542     size_t size = 0;
1543 
1544     size += vn_sizeof_VkStructureType(&val->sType);
1545     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(val->pNext);
1546     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(val);
1547 
1548     return size;
1549 }
1550 
1551 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1552 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1553 {
1554     /* no known/supported struct */
1555     vn_encode_simple_pointer(enc, NULL);
1556 }
1557 
1558 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1559 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1560 {
1561     /* skip val->{sType,pNext} */
1562     vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
1563     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
1564     vn_encode_VkBool32(enc, &val->storagePushConstant16);
1565     vn_encode_VkBool32(enc, &val->storageInputOutput16);
1566 }
1567 
1568 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1569 vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1570 {
1571     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1572     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
1573     vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(enc, val->pNext);
1574     vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, val);
1575 }
1576 
1577 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1578 vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1579 {
1580     /* no known/supported struct */
1581     if (vn_decode_simple_pointer(dec))
1582         assert(false);
1583 }
1584 
1585 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1586 vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1587 {
1588     /* skip val->{sType,pNext} */
1589     vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
1590     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
1591     vn_decode_VkBool32(dec, &val->storagePushConstant16);
1592     vn_decode_VkBool32(dec, &val->storageInputOutput16);
1593 }
1594 
1595 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1596 vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1597 {
1598     VkStructureType stype;
1599     vn_decode_VkStructureType(dec, &stype);
1600     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1601 
1602     assert(val->sType == stype);
1603     vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(dec, val->pNext);
1604     vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, val);
1605 }
1606 
1607 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void * val)1608 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void *val)
1609 {
1610     /* no known/supported struct */
1611     return vn_sizeof_simple_pointer(NULL);
1612 }
1613 
1614 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures * val)1615 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures *val)
1616 {
1617     size_t size = 0;
1618     /* skip val->{sType,pNext} */
1619     /* skip val->storageBuffer16BitAccess */
1620     /* skip val->uniformAndStorageBuffer16BitAccess */
1621     /* skip val->storagePushConstant16 */
1622     /* skip val->storageInputOutput16 */
1623     return size;
1624 }
1625 
1626 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures * val)1627 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures *val)
1628 {
1629     size_t size = 0;
1630 
1631     size += vn_sizeof_VkStructureType(&val->sType);
1632     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(val->pNext);
1633     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(val);
1634 
1635     return size;
1636 }
1637 
1638 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1639 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1640 {
1641     /* no known/supported struct */
1642     vn_encode_simple_pointer(enc, NULL);
1643 }
1644 
1645 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1646 vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1647 {
1648     /* skip val->{sType,pNext} */
1649     /* skip val->storageBuffer16BitAccess */
1650     /* skip val->uniformAndStorageBuffer16BitAccess */
1651     /* skip val->storagePushConstant16 */
1652     /* skip val->storageInputOutput16 */
1653 }
1654 
1655 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1656 vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1657 {
1658     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1659     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
1660     vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(enc, val->pNext);
1661     vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, val);
1662 }
1663 
1664 /* struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures chain */
1665 
1666 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void * val)1667 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void *val)
1668 {
1669     /* no known/supported struct */
1670     return vn_sizeof_simple_pointer(NULL);
1671 }
1672 
1673 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1674 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1675 {
1676     size_t size = 0;
1677     /* skip val->{sType,pNext} */
1678     size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
1679     return size;
1680 }
1681 
1682 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1683 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1684 {
1685     size_t size = 0;
1686 
1687     size += vn_sizeof_VkStructureType(&val->sType);
1688     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(val->pNext);
1689     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(val);
1690 
1691     return size;
1692 }
1693 
1694 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1695 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1696 {
1697     /* no known/supported struct */
1698     vn_encode_simple_pointer(enc, NULL);
1699 }
1700 
1701 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1702 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1703 {
1704     /* skip val->{sType,pNext} */
1705     vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
1706 }
1707 
1708 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1709 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1710 {
1711     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1712     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
1713     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(enc, val->pNext);
1714     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, val);
1715 }
1716 
1717 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1718 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1719 {
1720     /* no known/supported struct */
1721     if (vn_decode_simple_pointer(dec))
1722         assert(false);
1723 }
1724 
1725 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1726 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1727 {
1728     /* skip val->{sType,pNext} */
1729     vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
1730 }
1731 
1732 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1733 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1734 {
1735     VkStructureType stype;
1736     vn_decode_VkStructureType(dec, &stype);
1737     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1738 
1739     assert(val->sType == stype);
1740     vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(dec, val->pNext);
1741     vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, val);
1742 }
1743 
1744 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void * val)1745 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void *val)
1746 {
1747     /* no known/supported struct */
1748     return vn_sizeof_simple_pointer(NULL);
1749 }
1750 
1751 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1752 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1753 {
1754     size_t size = 0;
1755     /* skip val->{sType,pNext} */
1756     /* skip val->shaderSubgroupExtendedTypes */
1757     return size;
1758 }
1759 
1760 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1761 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1762 {
1763     size_t size = 0;
1764 
1765     size += vn_sizeof_VkStructureType(&val->sType);
1766     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(val->pNext);
1767     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(val);
1768 
1769     return size;
1770 }
1771 
1772 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1773 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1774 {
1775     /* no known/supported struct */
1776     vn_encode_simple_pointer(enc, NULL);
1777 }
1778 
1779 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1780 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1781 {
1782     /* skip val->{sType,pNext} */
1783     /* skip val->shaderSubgroupExtendedTypes */
1784 }
1785 
1786 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1787 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1788 {
1789     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1790     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
1791     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(enc, val->pNext);
1792     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, val);
1793 }
1794 
1795 /* struct VkPhysicalDeviceSamplerYcbcrConversionFeatures chain */
1796 
1797 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void * val)1798 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void *val)
1799 {
1800     /* no known/supported struct */
1801     return vn_sizeof_simple_pointer(NULL);
1802 }
1803 
1804 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1805 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1806 {
1807     size_t size = 0;
1808     /* skip val->{sType,pNext} */
1809     size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
1810     return size;
1811 }
1812 
1813 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1814 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1815 {
1816     size_t size = 0;
1817 
1818     size += vn_sizeof_VkStructureType(&val->sType);
1819     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(val->pNext);
1820     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(val);
1821 
1822     return size;
1823 }
1824 
1825 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1826 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1827 {
1828     /* no known/supported struct */
1829     vn_encode_simple_pointer(enc, NULL);
1830 }
1831 
1832 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1833 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1834 {
1835     /* skip val->{sType,pNext} */
1836     vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
1837 }
1838 
1839 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1840 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1841 {
1842     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
1843     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
1844     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(enc, val->pNext);
1845     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, val);
1846 }
1847 
1848 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1849 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1850 {
1851     /* no known/supported struct */
1852     if (vn_decode_simple_pointer(dec))
1853         assert(false);
1854 }
1855 
1856 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1857 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1858 {
1859     /* skip val->{sType,pNext} */
1860     vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
1861 }
1862 
1863 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1864 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1865 {
1866     VkStructureType stype;
1867     vn_decode_VkStructureType(dec, &stype);
1868     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
1869 
1870     assert(val->sType == stype);
1871     vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(dec, val->pNext);
1872     vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, val);
1873 }
1874 
1875 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void * val)1876 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void *val)
1877 {
1878     /* no known/supported struct */
1879     return vn_sizeof_simple_pointer(NULL);
1880 }
1881 
1882 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1883 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1884 {
1885     size_t size = 0;
1886     /* skip val->{sType,pNext} */
1887     /* skip val->samplerYcbcrConversion */
1888     return size;
1889 }
1890 
1891 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1892 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1893 {
1894     size_t size = 0;
1895 
1896     size += vn_sizeof_VkStructureType(&val->sType);
1897     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(val->pNext);
1898     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(val);
1899 
1900     return size;
1901 }
1902 
1903 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1904 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1905 {
1906     /* no known/supported struct */
1907     vn_encode_simple_pointer(enc, NULL);
1908 }
1909 
1910 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1911 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1912 {
1913     /* skip val->{sType,pNext} */
1914     /* skip val->samplerYcbcrConversion */
1915 }
1916 
1917 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1918 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1919 {
1920     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
1921     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
1922     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(enc, val->pNext);
1923     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, val);
1924 }
1925 
1926 /* struct VkPhysicalDeviceProtectedMemoryFeatures chain */
1927 
1928 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void * val)1929 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void *val)
1930 {
1931     /* no known/supported struct */
1932     return vn_sizeof_simple_pointer(NULL);
1933 }
1934 
1935 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures * val)1936 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures *val)
1937 {
1938     size_t size = 0;
1939     /* skip val->{sType,pNext} */
1940     size += vn_sizeof_VkBool32(&val->protectedMemory);
1941     return size;
1942 }
1943 
1944 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures * val)1945 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures *val)
1946 {
1947     size_t size = 0;
1948 
1949     size += vn_sizeof_VkStructureType(&val->sType);
1950     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(val->pNext);
1951     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(val);
1952 
1953     return size;
1954 }
1955 
1956 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1957 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1958 {
1959     /* no known/supported struct */
1960     vn_encode_simple_pointer(enc, NULL);
1961 }
1962 
1963 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)1964 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
1965 {
1966     /* skip val->{sType,pNext} */
1967     vn_encode_VkBool32(enc, &val->protectedMemory);
1968 }
1969 
1970 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)1971 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
1972 {
1973     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
1974     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
1975     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(enc, val->pNext);
1976     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, val);
1977 }
1978 
1979 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1980 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1981 {
1982     /* no known/supported struct */
1983     if (vn_decode_simple_pointer(dec))
1984         assert(false);
1985 }
1986 
1987 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1988 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1989 {
1990     /* skip val->{sType,pNext} */
1991     vn_decode_VkBool32(dec, &val->protectedMemory);
1992 }
1993 
1994 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)1995 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
1996 {
1997     VkStructureType stype;
1998     vn_decode_VkStructureType(dec, &stype);
1999     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
2000 
2001     assert(val->sType == stype);
2002     vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(dec, val->pNext);
2003     vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, val);
2004 }
2005 
2006 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void * val)2007 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void *val)
2008 {
2009     /* no known/supported struct */
2010     return vn_sizeof_simple_pointer(NULL);
2011 }
2012 
2013 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures * val)2014 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2015 {
2016     size_t size = 0;
2017     /* skip val->{sType,pNext} */
2018     /* skip val->protectedMemory */
2019     return size;
2020 }
2021 
2022 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures * val)2023 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2024 {
2025     size_t size = 0;
2026 
2027     size += vn_sizeof_VkStructureType(&val->sType);
2028     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(val->pNext);
2029     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(val);
2030 
2031     return size;
2032 }
2033 
2034 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2035 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2036 {
2037     /* no known/supported struct */
2038     vn_encode_simple_pointer(enc, NULL);
2039 }
2040 
2041 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2042 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2043 {
2044     /* skip val->{sType,pNext} */
2045     /* skip val->protectedMemory */
2046 }
2047 
2048 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2049 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2050 {
2051     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
2052     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
2053     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(enc, val->pNext);
2054     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, val);
2055 }
2056 
2057 /* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
2058 
2059 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void * val)2060 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void *val)
2061 {
2062     /* no known/supported struct */
2063     return vn_sizeof_simple_pointer(NULL);
2064 }
2065 
2066 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2067 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2068 {
2069     size_t size = 0;
2070     /* skip val->{sType,pNext} */
2071     size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
2072     return size;
2073 }
2074 
2075 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2076 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2077 {
2078     size_t size = 0;
2079 
2080     size += vn_sizeof_VkStructureType(&val->sType);
2081     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(val->pNext);
2082     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(val);
2083 
2084     return size;
2085 }
2086 
2087 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2088 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2089 {
2090     /* no known/supported struct */
2091     vn_encode_simple_pointer(enc, NULL);
2092 }
2093 
2094 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2095 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2096 {
2097     /* skip val->{sType,pNext} */
2098     vn_encode_VkBool32(enc, &val->shaderDrawParameters);
2099 }
2100 
2101 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2102 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2103 {
2104     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2105     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2106     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext);
2107     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val);
2108 }
2109 
2110 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2111 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2112 {
2113     /* no known/supported struct */
2114     if (vn_decode_simple_pointer(dec))
2115         assert(false);
2116 }
2117 
2118 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2119 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2120 {
2121     /* skip val->{sType,pNext} */
2122     vn_decode_VkBool32(dec, &val->shaderDrawParameters);
2123 }
2124 
2125 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2126 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2127 {
2128     VkStructureType stype;
2129     vn_decode_VkStructureType(dec, &stype);
2130     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2131 
2132     assert(val->sType == stype);
2133     vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(dec, val->pNext);
2134     vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, val);
2135 }
2136 
2137 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void * val)2138 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void *val)
2139 {
2140     /* no known/supported struct */
2141     return vn_sizeof_simple_pointer(NULL);
2142 }
2143 
2144 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2145 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2146 {
2147     size_t size = 0;
2148     /* skip val->{sType,pNext} */
2149     /* skip val->shaderDrawParameters */
2150     return size;
2151 }
2152 
2153 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2154 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2155 {
2156     size_t size = 0;
2157 
2158     size += vn_sizeof_VkStructureType(&val->sType);
2159     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(val->pNext);
2160     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(val);
2161 
2162     return size;
2163 }
2164 
2165 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2166 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2167 {
2168     /* no known/supported struct */
2169     vn_encode_simple_pointer(enc, NULL);
2170 }
2171 
2172 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2173 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2174 {
2175     /* skip val->{sType,pNext} */
2176     /* skip val->shaderDrawParameters */
2177 }
2178 
2179 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2180 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2181 {
2182     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2183     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2184     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(enc, val->pNext);
2185     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, val);
2186 }
2187 
2188 /* struct VkPhysicalDeviceShaderFloat16Int8Features chain */
2189 
2190 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void * val)2191 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void *val)
2192 {
2193     /* no known/supported struct */
2194     return vn_sizeof_simple_pointer(NULL);
2195 }
2196 
2197 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features * val)2198 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2199 {
2200     size_t size = 0;
2201     /* skip val->{sType,pNext} */
2202     size += vn_sizeof_VkBool32(&val->shaderFloat16);
2203     size += vn_sizeof_VkBool32(&val->shaderInt8);
2204     return size;
2205 }
2206 
2207 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * val)2208 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2209 {
2210     size_t size = 0;
2211 
2212     size += vn_sizeof_VkStructureType(&val->sType);
2213     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(val->pNext);
2214     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(val);
2215 
2216     return size;
2217 }
2218 
2219 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder * enc,const void * val)2220 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val)
2221 {
2222     /* no known/supported struct */
2223     vn_encode_simple_pointer(enc, NULL);
2224 }
2225 
2226 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2227 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2228 {
2229     /* skip val->{sType,pNext} */
2230     vn_encode_VkBool32(enc, &val->shaderFloat16);
2231     vn_encode_VkBool32(enc, &val->shaderInt8);
2232 }
2233 
2234 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2235 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2236 {
2237     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2238     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
2239     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext);
2240     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val);
2241 }
2242 
2243 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder * dec,const void * val)2244 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder *dec, const void *val)
2245 {
2246     /* no known/supported struct */
2247     if (vn_decode_simple_pointer(dec))
2248         assert(false);
2249 }
2250 
2251 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2252 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2253 {
2254     /* skip val->{sType,pNext} */
2255     vn_decode_VkBool32(dec, &val->shaderFloat16);
2256     vn_decode_VkBool32(dec, &val->shaderInt8);
2257 }
2258 
2259 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2260 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2261 {
2262     VkStructureType stype;
2263     vn_decode_VkStructureType(dec, &stype);
2264     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2265 
2266     assert(val->sType == stype);
2267     vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(dec, val->pNext);
2268     vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, val);
2269 }
2270 
2271 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void * val)2272 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void *val)
2273 {
2274     /* no known/supported struct */
2275     return vn_sizeof_simple_pointer(NULL);
2276 }
2277 
2278 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)2279 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2280 {
2281     size_t size = 0;
2282     /* skip val->{sType,pNext} */
2283     /* skip val->shaderFloat16 */
2284     /* skip val->shaderInt8 */
2285     return size;
2286 }
2287 
2288 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)2289 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2290 {
2291     size_t size = 0;
2292 
2293     size += vn_sizeof_VkStructureType(&val->sType);
2294     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(val->pNext);
2295     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(val);
2296 
2297     return size;
2298 }
2299 
2300 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)2301 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2302 {
2303     /* no known/supported struct */
2304     vn_encode_simple_pointer(enc, NULL);
2305 }
2306 
2307 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2308 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2309 {
2310     /* skip val->{sType,pNext} */
2311     /* skip val->shaderFloat16 */
2312     /* skip val->shaderInt8 */
2313 }
2314 
2315 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2316 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2317 {
2318     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2319     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
2320     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(enc, val->pNext);
2321     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, val);
2322 }
2323 
2324 /* struct VkPhysicalDeviceHostQueryResetFeatures chain */
2325 
2326 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void * val)2327 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void *val)
2328 {
2329     /* no known/supported struct */
2330     return vn_sizeof_simple_pointer(NULL);
2331 }
2332 
2333 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures * val)2334 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures *val)
2335 {
2336     size_t size = 0;
2337     /* skip val->{sType,pNext} */
2338     size += vn_sizeof_VkBool32(&val->hostQueryReset);
2339     return size;
2340 }
2341 
2342 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * val)2343 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *val)
2344 {
2345     size_t size = 0;
2346 
2347     size += vn_sizeof_VkStructureType(&val->sType);
2348     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(val->pNext);
2349     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(val);
2350 
2351     return size;
2352 }
2353 
2354 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2355 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2356 {
2357     /* no known/supported struct */
2358     vn_encode_simple_pointer(enc, NULL);
2359 }
2360 
2361 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2362 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2363 {
2364     /* skip val->{sType,pNext} */
2365     vn_encode_VkBool32(enc, &val->hostQueryReset);
2366 }
2367 
2368 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2369 vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2370 {
2371     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2372     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
2373     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext);
2374     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val);
2375 }
2376 
2377 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2378 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2379 {
2380     /* no known/supported struct */
2381     if (vn_decode_simple_pointer(dec))
2382         assert(false);
2383 }
2384 
2385 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)2386 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
2387 {
2388     /* skip val->{sType,pNext} */
2389     vn_decode_VkBool32(dec, &val->hostQueryReset);
2390 }
2391 
2392 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)2393 vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
2394 {
2395     VkStructureType stype;
2396     vn_decode_VkStructureType(dec, &stype);
2397     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2398 
2399     assert(val->sType == stype);
2400     vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(dec, val->pNext);
2401     vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, val);
2402 }
2403 
2404 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void * val)2405 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void *val)
2406 {
2407     /* no known/supported struct */
2408     return vn_sizeof_simple_pointer(NULL);
2409 }
2410 
2411 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)2412 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
2413 {
2414     size_t size = 0;
2415     /* skip val->{sType,pNext} */
2416     /* skip val->hostQueryReset */
2417     return size;
2418 }
2419 
2420 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)2421 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
2422 {
2423     size_t size = 0;
2424 
2425     size += vn_sizeof_VkStructureType(&val->sType);
2426     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(val->pNext);
2427     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(val);
2428 
2429     return size;
2430 }
2431 
2432 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2433 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2434 {
2435     /* no known/supported struct */
2436     vn_encode_simple_pointer(enc, NULL);
2437 }
2438 
2439 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2440 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2441 {
2442     /* skip val->{sType,pNext} */
2443     /* skip val->hostQueryReset */
2444 }
2445 
2446 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2447 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2448 {
2449     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2450     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
2451     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(enc, val->pNext);
2452     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, val);
2453 }
2454 
2455 /* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */
2456 
2457 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void * val)2458 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void *val)
2459 {
2460     /* no known/supported struct */
2461     return vn_sizeof_simple_pointer(NULL);
2462 }
2463 
2464 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2465 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2466 {
2467     size_t size = 0;
2468     /* skip val->{sType,pNext} */
2469     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
2470     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
2471     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
2472     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
2473     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
2474     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
2475     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
2476     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
2477     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
2478     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
2479     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
2480     size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
2481     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
2482     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
2483     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2484     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2485     size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
2486     size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
2487     size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
2488     size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
2489     return size;
2490 }
2491 
2492 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2493 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2494 {
2495     size_t size = 0;
2496 
2497     size += vn_sizeof_VkStructureType(&val->sType);
2498     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(val->pNext);
2499     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(val);
2500 
2501     return size;
2502 }
2503 
2504 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2505 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2506 {
2507     /* no known/supported struct */
2508     vn_encode_simple_pointer(enc, NULL);
2509 }
2510 
2511 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2512 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2513 {
2514     /* skip val->{sType,pNext} */
2515     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
2516     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
2517     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
2518     vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
2519     vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
2520     vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
2521     vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
2522     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
2523     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
2524     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
2525     vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
2526     vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
2527     vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
2528     vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
2529     vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2530     vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2531     vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
2532     vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
2533     vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
2534     vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
2535 }
2536 
2537 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2538 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2539 {
2540     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
2541     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
2542     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext);
2543     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val);
2544 }
2545 
2546 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2547 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2548 {
2549     /* no known/supported struct */
2550     if (vn_decode_simple_pointer(dec))
2551         assert(false);
2552 }
2553 
2554 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)2555 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
2556 {
2557     /* skip val->{sType,pNext} */
2558     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
2559     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
2560     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
2561     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
2562     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
2563     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
2564     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
2565     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
2566     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
2567     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
2568     vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
2569     vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
2570     vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
2571     vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
2572     vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2573     vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2574     vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
2575     vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
2576     vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
2577     vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
2578 }
2579 
2580 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)2581 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
2582 {
2583     VkStructureType stype;
2584     vn_decode_VkStructureType(dec, &stype);
2585     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
2586 
2587     assert(val->sType == stype);
2588     vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(dec, val->pNext);
2589     vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, val);
2590 }
2591 
2592 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void * val)2593 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void *val)
2594 {
2595     /* no known/supported struct */
2596     return vn_sizeof_simple_pointer(NULL);
2597 }
2598 
2599 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2600 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2601 {
2602     size_t size = 0;
2603     /* skip val->{sType,pNext} */
2604     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
2605     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
2606     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
2607     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
2608     /* skip val->shaderSampledImageArrayNonUniformIndexing */
2609     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
2610     /* skip val->shaderStorageImageArrayNonUniformIndexing */
2611     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
2612     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
2613     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
2614     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
2615     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
2616     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
2617     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
2618     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
2619     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
2620     /* skip val->descriptorBindingUpdateUnusedWhilePending */
2621     /* skip val->descriptorBindingPartiallyBound */
2622     /* skip val->descriptorBindingVariableDescriptorCount */
2623     /* skip val->runtimeDescriptorArray */
2624     return size;
2625 }
2626 
2627 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2628 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2629 {
2630     size_t size = 0;
2631 
2632     size += vn_sizeof_VkStructureType(&val->sType);
2633     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(val->pNext);
2634     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(val);
2635 
2636     return size;
2637 }
2638 
2639 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2640 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2641 {
2642     /* no known/supported struct */
2643     vn_encode_simple_pointer(enc, NULL);
2644 }
2645 
2646 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2647 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2648 {
2649     /* skip val->{sType,pNext} */
2650     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
2651     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
2652     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
2653     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
2654     /* skip val->shaderSampledImageArrayNonUniformIndexing */
2655     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
2656     /* skip val->shaderStorageImageArrayNonUniformIndexing */
2657     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
2658     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
2659     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
2660     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
2661     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
2662     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
2663     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
2664     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
2665     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
2666     /* skip val->descriptorBindingUpdateUnusedWhilePending */
2667     /* skip val->descriptorBindingPartiallyBound */
2668     /* skip val->descriptorBindingVariableDescriptorCount */
2669     /* skip val->runtimeDescriptorArray */
2670 }
2671 
2672 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2673 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2674 {
2675     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
2676     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
2677     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(enc, val->pNext);
2678     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, val);
2679 }
2680 
2681 /* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */
2682 
2683 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void * val)2684 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void *val)
2685 {
2686     /* no known/supported struct */
2687     return vn_sizeof_simple_pointer(NULL);
2688 }
2689 
2690 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2691 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2692 {
2693     size_t size = 0;
2694     /* skip val->{sType,pNext} */
2695     size += vn_sizeof_VkBool32(&val->timelineSemaphore);
2696     return size;
2697 }
2698 
2699 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2700 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2701 {
2702     size_t size = 0;
2703 
2704     size += vn_sizeof_VkStructureType(&val->sType);
2705     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(val->pNext);
2706     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(val);
2707 
2708     return size;
2709 }
2710 
2711 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2712 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2713 {
2714     /* no known/supported struct */
2715     vn_encode_simple_pointer(enc, NULL);
2716 }
2717 
2718 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2719 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2720 {
2721     /* skip val->{sType,pNext} */
2722     vn_encode_VkBool32(enc, &val->timelineSemaphore);
2723 }
2724 
2725 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2726 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2727 {
2728     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
2729     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
2730     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext);
2731     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val);
2732 }
2733 
2734 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2735 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2736 {
2737     /* no known/supported struct */
2738     if (vn_decode_simple_pointer(dec))
2739         assert(false);
2740 }
2741 
2742 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)2743 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2744 {
2745     /* skip val->{sType,pNext} */
2746     vn_decode_VkBool32(dec, &val->timelineSemaphore);
2747 }
2748 
2749 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)2750 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2751 {
2752     VkStructureType stype;
2753     vn_decode_VkStructureType(dec, &stype);
2754     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
2755 
2756     assert(val->sType == stype);
2757     vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(dec, val->pNext);
2758     vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, val);
2759 }
2760 
2761 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void * val)2762 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void *val)
2763 {
2764     /* no known/supported struct */
2765     return vn_sizeof_simple_pointer(NULL);
2766 }
2767 
2768 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2769 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2770 {
2771     size_t size = 0;
2772     /* skip val->{sType,pNext} */
2773     /* skip val->timelineSemaphore */
2774     return size;
2775 }
2776 
2777 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2778 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2779 {
2780     size_t size = 0;
2781 
2782     size += vn_sizeof_VkStructureType(&val->sType);
2783     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(val->pNext);
2784     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(val);
2785 
2786     return size;
2787 }
2788 
2789 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2790 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2791 {
2792     /* no known/supported struct */
2793     vn_encode_simple_pointer(enc, NULL);
2794 }
2795 
2796 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2797 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2798 {
2799     /* skip val->{sType,pNext} */
2800     /* skip val->timelineSemaphore */
2801 }
2802 
2803 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)2804 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
2805 {
2806     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
2807     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
2808     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(enc, val->pNext);
2809     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, val);
2810 }
2811 
2812 /* struct VkPhysicalDevice8BitStorageFeatures chain */
2813 
2814 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void * val)2815 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void *val)
2816 {
2817     /* no known/supported struct */
2818     return vn_sizeof_simple_pointer(NULL);
2819 }
2820 
2821 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures * val)2822 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures *val)
2823 {
2824     size_t size = 0;
2825     /* skip val->{sType,pNext} */
2826     size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
2827     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
2828     size += vn_sizeof_VkBool32(&val->storagePushConstant8);
2829     return size;
2830 }
2831 
2832 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * val)2833 vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *val)
2834 {
2835     size_t size = 0;
2836 
2837     size += vn_sizeof_VkStructureType(&val->sType);
2838     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(val->pNext);
2839     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(val);
2840 
2841     return size;
2842 }
2843 
2844 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2845 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2846 {
2847     /* no known/supported struct */
2848     vn_encode_simple_pointer(enc, NULL);
2849 }
2850 
2851 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2852 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2853 {
2854     /* skip val->{sType,pNext} */
2855     vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
2856     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
2857     vn_encode_VkBool32(enc, &val->storagePushConstant8);
2858 }
2859 
2860 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2861 vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2862 {
2863     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2864     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
2865     vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext);
2866     vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val);
2867 }
2868 
2869 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2870 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2871 {
2872     /* no known/supported struct */
2873     if (vn_decode_simple_pointer(dec))
2874         assert(false);
2875 }
2876 
2877 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2878 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2879 {
2880     /* skip val->{sType,pNext} */
2881     vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
2882     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
2883     vn_decode_VkBool32(dec, &val->storagePushConstant8);
2884 }
2885 
2886 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)2887 vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
2888 {
2889     VkStructureType stype;
2890     vn_decode_VkStructureType(dec, &stype);
2891     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2892 
2893     assert(val->sType == stype);
2894     vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(dec, val->pNext);
2895     vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, val);
2896 }
2897 
2898 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void * val)2899 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void *val)
2900 {
2901     /* no known/supported struct */
2902     return vn_sizeof_simple_pointer(NULL);
2903 }
2904 
2905 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures * val)2906 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures *val)
2907 {
2908     size_t size = 0;
2909     /* skip val->{sType,pNext} */
2910     /* skip val->storageBuffer8BitAccess */
2911     /* skip val->uniformAndStorageBuffer8BitAccess */
2912     /* skip val->storagePushConstant8 */
2913     return size;
2914 }
2915 
2916 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures * val)2917 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures *val)
2918 {
2919     size_t size = 0;
2920 
2921     size += vn_sizeof_VkStructureType(&val->sType);
2922     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(val->pNext);
2923     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(val);
2924 
2925     return size;
2926 }
2927 
2928 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2929 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2930 {
2931     /* no known/supported struct */
2932     vn_encode_simple_pointer(enc, NULL);
2933 }
2934 
2935 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2936 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2937 {
2938     /* skip val->{sType,pNext} */
2939     /* skip val->storageBuffer8BitAccess */
2940     /* skip val->uniformAndStorageBuffer8BitAccess */
2941     /* skip val->storagePushConstant8 */
2942 }
2943 
2944 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)2945 vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
2946 {
2947     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
2948     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
2949     vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(enc, val->pNext);
2950     vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, val);
2951 }
2952 
2953 /* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */
2954 
2955 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void * val)2956 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void *val)
2957 {
2958     /* no known/supported struct */
2959     return vn_sizeof_simple_pointer(NULL);
2960 }
2961 
2962 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2963 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2964 {
2965     size_t size = 0;
2966     /* skip val->{sType,pNext} */
2967     size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
2968     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
2969     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
2970     return size;
2971 }
2972 
2973 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2974 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2975 {
2976     size_t size = 0;
2977 
2978     size += vn_sizeof_VkStructureType(&val->sType);
2979     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(val->pNext);
2980     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(val);
2981 
2982     return size;
2983 }
2984 
2985 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2986 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2987 {
2988     /* no known/supported struct */
2989     vn_encode_simple_pointer(enc, NULL);
2990 }
2991 
2992 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)2993 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
2994 {
2995     /* skip val->{sType,pNext} */
2996     vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
2997     vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
2998     vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
2999 }
3000 
3001 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3002 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3003 {
3004     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3005     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3006     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext);
3007     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val);
3008 }
3009 
3010 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3011 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3012 {
3013     /* no known/supported struct */
3014     if (vn_decode_simple_pointer(dec))
3015         assert(false);
3016 }
3017 
3018 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3019 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3020 {
3021     /* skip val->{sType,pNext} */
3022     vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
3023     vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
3024     vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3025 }
3026 
3027 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3028 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3029 {
3030     VkStructureType stype;
3031     vn_decode_VkStructureType(dec, &stype);
3032     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3033 
3034     assert(val->sType == stype);
3035     vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(dec, val->pNext);
3036     vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, val);
3037 }
3038 
3039 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void * val)3040 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void *val)
3041 {
3042     /* no known/supported struct */
3043     return vn_sizeof_simple_pointer(NULL);
3044 }
3045 
3046 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3047 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3048 {
3049     size_t size = 0;
3050     /* skip val->{sType,pNext} */
3051     /* skip val->vulkanMemoryModel */
3052     /* skip val->vulkanMemoryModelDeviceScope */
3053     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3054     return size;
3055 }
3056 
3057 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3058 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3059 {
3060     size_t size = 0;
3061 
3062     size += vn_sizeof_VkStructureType(&val->sType);
3063     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(val->pNext);
3064     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(val);
3065 
3066     return size;
3067 }
3068 
3069 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3070 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3071 {
3072     /* no known/supported struct */
3073     vn_encode_simple_pointer(enc, NULL);
3074 }
3075 
3076 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3077 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3078 {
3079     /* skip val->{sType,pNext} */
3080     /* skip val->vulkanMemoryModel */
3081     /* skip val->vulkanMemoryModelDeviceScope */
3082     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3083 }
3084 
3085 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3086 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3087 {
3088     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3089     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3090     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(enc, val->pNext);
3091     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, val);
3092 }
3093 
3094 /* struct VkPhysicalDeviceShaderAtomicInt64Features chain */
3095 
3096 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void * val)3097 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void *val)
3098 {
3099     /* no known/supported struct */
3100     return vn_sizeof_simple_pointer(NULL);
3101 }
3102 
3103 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features * val)3104 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3105 {
3106     size_t size = 0;
3107     /* skip val->{sType,pNext} */
3108     size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
3109     size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
3110     return size;
3111 }
3112 
3113 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * val)3114 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3115 {
3116     size_t size = 0;
3117 
3118     size += vn_sizeof_VkStructureType(&val->sType);
3119     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(val->pNext);
3120     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(val);
3121 
3122     return size;
3123 }
3124 
3125 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder * enc,const void * val)3126 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val)
3127 {
3128     /* no known/supported struct */
3129     vn_encode_simple_pointer(enc, NULL);
3130 }
3131 
3132 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3133 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3134 {
3135     /* skip val->{sType,pNext} */
3136     vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
3137     vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
3138 }
3139 
3140 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3141 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3142 {
3143     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3144     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
3145     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext);
3146     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val);
3147 }
3148 
3149 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder * dec,const void * val)3150 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder *dec, const void *val)
3151 {
3152     /* no known/supported struct */
3153     if (vn_decode_simple_pointer(dec))
3154         assert(false);
3155 }
3156 
3157 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)3158 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
3159 {
3160     /* skip val->{sType,pNext} */
3161     vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
3162     vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
3163 }
3164 
3165 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)3166 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
3167 {
3168     VkStructureType stype;
3169     vn_decode_VkStructureType(dec, &stype);
3170     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3171 
3172     assert(val->sType == stype);
3173     vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(dec, val->pNext);
3174     vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, val);
3175 }
3176 
3177 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void * val)3178 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void *val)
3179 {
3180     /* no known/supported struct */
3181     return vn_sizeof_simple_pointer(NULL);
3182 }
3183 
3184 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)3185 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3186 {
3187     size_t size = 0;
3188     /* skip val->{sType,pNext} */
3189     /* skip val->shaderBufferInt64Atomics */
3190     /* skip val->shaderSharedInt64Atomics */
3191     return size;
3192 }
3193 
3194 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)3195 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3196 {
3197     size_t size = 0;
3198 
3199     size += vn_sizeof_VkStructureType(&val->sType);
3200     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(val->pNext);
3201     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(val);
3202 
3203     return size;
3204 }
3205 
3206 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)3207 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3208 {
3209     /* no known/supported struct */
3210     vn_encode_simple_pointer(enc, NULL);
3211 }
3212 
3213 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3214 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3215 {
3216     /* skip val->{sType,pNext} */
3217     /* skip val->shaderBufferInt64Atomics */
3218     /* skip val->shaderSharedInt64Atomics */
3219 }
3220 
3221 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3222 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3223 {
3224     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3225     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
3226     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(enc, val->pNext);
3227     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, val);
3228 }
3229 
3230 /* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */
3231 
3232 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void * val)3233 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void *val)
3234 {
3235     /* no known/supported struct */
3236     return vn_sizeof_simple_pointer(NULL);
3237 }
3238 
3239 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3240 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3241 {
3242     size_t size = 0;
3243     /* skip val->{sType,pNext} */
3244     size += vn_sizeof_VkBool32(&val->transformFeedback);
3245     size += vn_sizeof_VkBool32(&val->geometryStreams);
3246     return size;
3247 }
3248 
3249 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3250 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3251 {
3252     size_t size = 0;
3253 
3254     size += vn_sizeof_VkStructureType(&val->sType);
3255     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(val->pNext);
3256     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(val);
3257 
3258     return size;
3259 }
3260 
3261 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)3262 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
3263 {
3264     /* no known/supported struct */
3265     vn_encode_simple_pointer(enc, NULL);
3266 }
3267 
3268 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3269 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3270 {
3271     /* skip val->{sType,pNext} */
3272     vn_encode_VkBool32(enc, &val->transformFeedback);
3273     vn_encode_VkBool32(enc, &val->geometryStreams);
3274 }
3275 
3276 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3277 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3278 {
3279     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
3280     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
3281     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext);
3282     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val);
3283 }
3284 
3285 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)3286 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
3287 {
3288     /* no known/supported struct */
3289     if (vn_decode_simple_pointer(dec))
3290         assert(false);
3291 }
3292 
3293 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3294 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3295 {
3296     /* skip val->{sType,pNext} */
3297     vn_decode_VkBool32(dec, &val->transformFeedback);
3298     vn_decode_VkBool32(dec, &val->geometryStreams);
3299 }
3300 
3301 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3302 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3303 {
3304     VkStructureType stype;
3305     vn_decode_VkStructureType(dec, &stype);
3306     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
3307 
3308     assert(val->sType == stype);
3309     vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(dec, val->pNext);
3310     vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, val);
3311 }
3312 
3313 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void * val)3314 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void *val)
3315 {
3316     /* no known/supported struct */
3317     return vn_sizeof_simple_pointer(NULL);
3318 }
3319 
3320 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3321 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3322 {
3323     size_t size = 0;
3324     /* skip val->{sType,pNext} */
3325     /* skip val->transformFeedback */
3326     /* skip val->geometryStreams */
3327     return size;
3328 }
3329 
3330 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3331 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3332 {
3333     size_t size = 0;
3334 
3335     size += vn_sizeof_VkStructureType(&val->sType);
3336     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(val->pNext);
3337     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(val);
3338 
3339     return size;
3340 }
3341 
3342 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)3343 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3344 {
3345     /* no known/supported struct */
3346     vn_encode_simple_pointer(enc, NULL);
3347 }
3348 
3349 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3350 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3351 {
3352     /* skip val->{sType,pNext} */
3353     /* skip val->transformFeedback */
3354     /* skip val->geometryStreams */
3355 }
3356 
3357 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3358 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3359 {
3360     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
3361     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
3362     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(enc, val->pNext);
3363     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, val);
3364 }
3365 
3366 /* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */
3367 
3368 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void * val)3369 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void *val)
3370 {
3371     /* no known/supported struct */
3372     return vn_sizeof_simple_pointer(NULL);
3373 }
3374 
3375 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3376 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3377 {
3378     size_t size = 0;
3379     /* skip val->{sType,pNext} */
3380     size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
3381     return size;
3382 }
3383 
3384 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3385 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3386 {
3387     size_t size = 0;
3388 
3389     size += vn_sizeof_VkStructureType(&val->sType);
3390     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(val->pNext);
3391     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(val);
3392 
3393     return size;
3394 }
3395 
3396 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3397 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3398 {
3399     /* no known/supported struct */
3400     vn_encode_simple_pointer(enc, NULL);
3401 }
3402 
3403 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3404 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3405 {
3406     /* skip val->{sType,pNext} */
3407     vn_encode_VkBool32(enc, &val->scalarBlockLayout);
3408 }
3409 
3410 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3411 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3412 {
3413     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
3414     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
3415     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext);
3416     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val);
3417 }
3418 
3419 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3420 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3421 {
3422     /* no known/supported struct */
3423     if (vn_decode_simple_pointer(dec))
3424         assert(false);
3425 }
3426 
3427 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)3428 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3429 {
3430     /* skip val->{sType,pNext} */
3431     vn_decode_VkBool32(dec, &val->scalarBlockLayout);
3432 }
3433 
3434 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)3435 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3436 {
3437     VkStructureType stype;
3438     vn_decode_VkStructureType(dec, &stype);
3439     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
3440 
3441     assert(val->sType == stype);
3442     vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(dec, val->pNext);
3443     vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, val);
3444 }
3445 
3446 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void * val)3447 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void *val)
3448 {
3449     /* no known/supported struct */
3450     return vn_sizeof_simple_pointer(NULL);
3451 }
3452 
3453 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3454 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3455 {
3456     size_t size = 0;
3457     /* skip val->{sType,pNext} */
3458     /* skip val->scalarBlockLayout */
3459     return size;
3460 }
3461 
3462 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3463 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3464 {
3465     size_t size = 0;
3466 
3467     size += vn_sizeof_VkStructureType(&val->sType);
3468     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(val->pNext);
3469     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(val);
3470 
3471     return size;
3472 }
3473 
3474 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3475 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3476 {
3477     /* no known/supported struct */
3478     vn_encode_simple_pointer(enc, NULL);
3479 }
3480 
3481 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3482 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3483 {
3484     /* skip val->{sType,pNext} */
3485     /* skip val->scalarBlockLayout */
3486 }
3487 
3488 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)3489 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
3490 {
3491     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
3492     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
3493     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(enc, val->pNext);
3494     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, val);
3495 }
3496 
3497 /* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */
3498 
3499 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void * val)3500 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void *val)
3501 {
3502     /* no known/supported struct */
3503     return vn_sizeof_simple_pointer(NULL);
3504 }
3505 
3506 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3507 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3508 {
3509     size_t size = 0;
3510     /* skip val->{sType,pNext} */
3511     size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
3512     return size;
3513 }
3514 
3515 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3516 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3517 {
3518     size_t size = 0;
3519 
3520     size += vn_sizeof_VkStructureType(&val->sType);
3521     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(val->pNext);
3522     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(val);
3523 
3524     return size;
3525 }
3526 
3527 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3528 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3529 {
3530     /* no known/supported struct */
3531     vn_encode_simple_pointer(enc, NULL);
3532 }
3533 
3534 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3535 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3536 {
3537     /* skip val->{sType,pNext} */
3538     vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
3539 }
3540 
3541 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3542 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3543 {
3544     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
3545     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
3546     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext);
3547     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val);
3548 }
3549 
3550 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3551 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3552 {
3553     /* no known/supported struct */
3554     if (vn_decode_simple_pointer(dec))
3555         assert(false);
3556 }
3557 
3558 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3559 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3560 {
3561     /* skip val->{sType,pNext} */
3562     vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
3563 }
3564 
3565 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3566 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3567 {
3568     VkStructureType stype;
3569     vn_decode_VkStructureType(dec, &stype);
3570     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
3571 
3572     assert(val->sType == stype);
3573     vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(dec, val->pNext);
3574     vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, val);
3575 }
3576 
3577 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void * val)3578 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void *val)
3579 {
3580     /* no known/supported struct */
3581     return vn_sizeof_simple_pointer(NULL);
3582 }
3583 
3584 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3585 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3586 {
3587     size_t size = 0;
3588     /* skip val->{sType,pNext} */
3589     /* skip val->uniformBufferStandardLayout */
3590     return size;
3591 }
3592 
3593 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3594 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3595 {
3596     size_t size = 0;
3597 
3598     size += vn_sizeof_VkStructureType(&val->sType);
3599     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(val->pNext);
3600     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(val);
3601 
3602     return size;
3603 }
3604 
3605 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3606 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3607 {
3608     /* no known/supported struct */
3609     vn_encode_simple_pointer(enc, NULL);
3610 }
3611 
3612 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3613 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3614 {
3615     /* skip val->{sType,pNext} */
3616     /* skip val->uniformBufferStandardLayout */
3617 }
3618 
3619 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)3620 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
3621 {
3622     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
3623     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
3624     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(enc, val->pNext);
3625     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, val);
3626 }
3627 
3628 /* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */
3629 
3630 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void * val)3631 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void *val)
3632 {
3633     /* no known/supported struct */
3634     return vn_sizeof_simple_pointer(NULL);
3635 }
3636 
3637 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3638 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3639 {
3640     size_t size = 0;
3641     /* skip val->{sType,pNext} */
3642     size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
3643     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
3644     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
3645     return size;
3646 }
3647 
3648 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3649 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3650 {
3651     size_t size = 0;
3652 
3653     size += vn_sizeof_VkStructureType(&val->sType);
3654     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(val->pNext);
3655     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(val);
3656 
3657     return size;
3658 }
3659 
3660 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3661 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3662 {
3663     /* no known/supported struct */
3664     vn_encode_simple_pointer(enc, NULL);
3665 }
3666 
3667 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3668 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3669 {
3670     /* skip val->{sType,pNext} */
3671     vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
3672     vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
3673     vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
3674 }
3675 
3676 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3677 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3678 {
3679     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
3680     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
3681     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext);
3682     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val);
3683 }
3684 
3685 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3686 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3687 {
3688     /* no known/supported struct */
3689     if (vn_decode_simple_pointer(dec))
3690         assert(false);
3691 }
3692 
3693 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)3694 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3695 {
3696     /* skip val->{sType,pNext} */
3697     vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
3698     vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
3699     vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
3700 }
3701 
3702 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)3703 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3704 {
3705     VkStructureType stype;
3706     vn_decode_VkStructureType(dec, &stype);
3707     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
3708 
3709     assert(val->sType == stype);
3710     vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(dec, val->pNext);
3711     vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, val);
3712 }
3713 
3714 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void * val)3715 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void *val)
3716 {
3717     /* no known/supported struct */
3718     return vn_sizeof_simple_pointer(NULL);
3719 }
3720 
3721 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3722 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3723 {
3724     size_t size = 0;
3725     /* skip val->{sType,pNext} */
3726     /* skip val->bufferDeviceAddress */
3727     /* skip val->bufferDeviceAddressCaptureReplay */
3728     /* skip val->bufferDeviceAddressMultiDevice */
3729     return size;
3730 }
3731 
3732 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3733 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3734 {
3735     size_t size = 0;
3736 
3737     size += vn_sizeof_VkStructureType(&val->sType);
3738     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(val->pNext);
3739     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(val);
3740 
3741     return size;
3742 }
3743 
3744 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3745 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3746 {
3747     /* no known/supported struct */
3748     vn_encode_simple_pointer(enc, NULL);
3749 }
3750 
3751 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3752 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3753 {
3754     /* skip val->{sType,pNext} */
3755     /* skip val->bufferDeviceAddress */
3756     /* skip val->bufferDeviceAddressCaptureReplay */
3757     /* skip val->bufferDeviceAddressMultiDevice */
3758 }
3759 
3760 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)3761 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
3762 {
3763     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
3764     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
3765     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(enc, val->pNext);
3766     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, val);
3767 }
3768 
3769 /* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */
3770 
3771 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void * val)3772 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void *val)
3773 {
3774     /* no known/supported struct */
3775     return vn_sizeof_simple_pointer(NULL);
3776 }
3777 
3778 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3779 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3780 {
3781     size_t size = 0;
3782     /* skip val->{sType,pNext} */
3783     size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
3784     return size;
3785 }
3786 
3787 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3788 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3789 {
3790     size_t size = 0;
3791 
3792     size += vn_sizeof_VkStructureType(&val->sType);
3793     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(val->pNext);
3794     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(val);
3795 
3796     return size;
3797 }
3798 
3799 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3800 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3801 {
3802     /* no known/supported struct */
3803     vn_encode_simple_pointer(enc, NULL);
3804 }
3805 
3806 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3807 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3808 {
3809     /* skip val->{sType,pNext} */
3810     vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
3811 }
3812 
3813 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3814 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3815 {
3816     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
3817     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
3818     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext);
3819     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val);
3820 }
3821 
3822 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3823 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3824 {
3825     /* no known/supported struct */
3826     if (vn_decode_simple_pointer(dec))
3827         assert(false);
3828 }
3829 
3830 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)3831 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
3832 {
3833     /* skip val->{sType,pNext} */
3834     vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
3835 }
3836 
3837 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)3838 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
3839 {
3840     VkStructureType stype;
3841     vn_decode_VkStructureType(dec, &stype);
3842     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
3843 
3844     assert(val->sType == stype);
3845     vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(dec, val->pNext);
3846     vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, val);
3847 }
3848 
3849 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void * val)3850 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void *val)
3851 {
3852     /* no known/supported struct */
3853     return vn_sizeof_simple_pointer(NULL);
3854 }
3855 
3856 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3857 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3858 {
3859     size_t size = 0;
3860     /* skip val->{sType,pNext} */
3861     /* skip val->imagelessFramebuffer */
3862     return size;
3863 }
3864 
3865 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)3866 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3867 {
3868     size_t size = 0;
3869 
3870     size += vn_sizeof_VkStructureType(&val->sType);
3871     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(val->pNext);
3872     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(val);
3873 
3874     return size;
3875 }
3876 
3877 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3878 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3879 {
3880     /* no known/supported struct */
3881     vn_encode_simple_pointer(enc, NULL);
3882 }
3883 
3884 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3885 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3886 {
3887     /* skip val->{sType,pNext} */
3888     /* skip val->imagelessFramebuffer */
3889 }
3890 
3891 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)3892 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
3893 {
3894     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
3895     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
3896     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(enc, val->pNext);
3897     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val);
3898 }
3899 
3900 /* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */
3901 
3902 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void * val)3903 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void *val)
3904 {
3905     /* no known/supported struct */
3906     return vn_sizeof_simple_pointer(NULL);
3907 }
3908 
3909 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3910 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3911 {
3912     size_t size = 0;
3913     /* skip val->{sType,pNext} */
3914     size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
3915     return size;
3916 }
3917 
3918 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3919 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3920 {
3921     size_t size = 0;
3922 
3923     size += vn_sizeof_VkStructureType(&val->sType);
3924     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(val->pNext);
3925     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(val);
3926 
3927     return size;
3928 }
3929 
3930 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3931 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3932 {
3933     /* no known/supported struct */
3934     vn_encode_simple_pointer(enc, NULL);
3935 }
3936 
3937 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3938 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3939 {
3940     /* skip val->{sType,pNext} */
3941     vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
3942 }
3943 
3944 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3945 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3946 {
3947     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
3948     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
3949     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext);
3950     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val);
3951 }
3952 
3953 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3954 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3955 {
3956     /* no known/supported struct */
3957     if (vn_decode_simple_pointer(dec))
3958         assert(false);
3959 }
3960 
3961 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3962 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3963 {
3964     /* skip val->{sType,pNext} */
3965     vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
3966 }
3967 
3968 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3969 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3970 {
3971     VkStructureType stype;
3972     vn_decode_VkStructureType(dec, &stype);
3973     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
3974 
3975     assert(val->sType == stype);
3976     vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(dec, val->pNext);
3977     vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, val);
3978 }
3979 
3980 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void * val)3981 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void *val)
3982 {
3983     /* no known/supported struct */
3984     return vn_sizeof_simple_pointer(NULL);
3985 }
3986 
3987 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3988 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3989 {
3990     size_t size = 0;
3991     /* skip val->{sType,pNext} */
3992     /* skip val->separateDepthStencilLayouts */
3993     return size;
3994 }
3995 
3996 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)3997 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
3998 {
3999     size_t size = 0;
4000 
4001     size += vn_sizeof_VkStructureType(&val->sType);
4002     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(val->pNext);
4003     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(val);
4004 
4005     return size;
4006 }
4007 
4008 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4009 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4010 {
4011     /* no known/supported struct */
4012     vn_encode_simple_pointer(enc, NULL);
4013 }
4014 
4015 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)4016 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
4017 {
4018     /* skip val->{sType,pNext} */
4019     /* skip val->separateDepthStencilLayouts */
4020 }
4021 
4022 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)4023 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
4024 {
4025     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
4026     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
4027     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(enc, val->pNext);
4028     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val);
4029 }
4030 
4031 /* struct VkPhysicalDeviceVulkan11Features chain */
4032 
4033 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void * val)4034 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void *val)
4035 {
4036     /* no known/supported struct */
4037     return vn_sizeof_simple_pointer(NULL);
4038 }
4039 
4040 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features * val)4041 vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features *val)
4042 {
4043     size_t size = 0;
4044     /* skip val->{sType,pNext} */
4045     size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
4046     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
4047     size += vn_sizeof_VkBool32(&val->storagePushConstant16);
4048     size += vn_sizeof_VkBool32(&val->storageInputOutput16);
4049     size += vn_sizeof_VkBool32(&val->multiview);
4050     size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
4051     size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
4052     size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
4053     size += vn_sizeof_VkBool32(&val->variablePointers);
4054     size += vn_sizeof_VkBool32(&val->protectedMemory);
4055     size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
4056     size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
4057     return size;
4058 }
4059 
4060 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features * val)4061 vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *val)
4062 {
4063     size_t size = 0;
4064 
4065     size += vn_sizeof_VkStructureType(&val->sType);
4066     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(val->pNext);
4067     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self(val);
4068 
4069     return size;
4070 }
4071 
4072 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder * enc,const void * val)4073 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val)
4074 {
4075     /* no known/supported struct */
4076     vn_encode_simple_pointer(enc, NULL);
4077 }
4078 
4079 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4080 vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4081 {
4082     /* skip val->{sType,pNext} */
4083     vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
4084     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
4085     vn_encode_VkBool32(enc, &val->storagePushConstant16);
4086     vn_encode_VkBool32(enc, &val->storageInputOutput16);
4087     vn_encode_VkBool32(enc, &val->multiview);
4088     vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
4089     vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
4090     vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
4091     vn_encode_VkBool32(enc, &val->variablePointers);
4092     vn_encode_VkBool32(enc, &val->protectedMemory);
4093     vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
4094     vn_encode_VkBool32(enc, &val->shaderDrawParameters);
4095 }
4096 
4097 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4098 vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4099 {
4100     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
4101     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
4102     vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext);
4103     vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val);
4104 }
4105 
4106 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder * dec,const void * val)4107 vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder *dec, const void *val)
4108 {
4109     /* no known/supported struct */
4110     if (vn_decode_simple_pointer(dec))
4111         assert(false);
4112 }
4113 
4114 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)4115 vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
4116 {
4117     /* skip val->{sType,pNext} */
4118     vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
4119     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
4120     vn_decode_VkBool32(dec, &val->storagePushConstant16);
4121     vn_decode_VkBool32(dec, &val->storageInputOutput16);
4122     vn_decode_VkBool32(dec, &val->multiview);
4123     vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
4124     vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
4125     vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
4126     vn_decode_VkBool32(dec, &val->variablePointers);
4127     vn_decode_VkBool32(dec, &val->protectedMemory);
4128     vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
4129     vn_decode_VkBool32(dec, &val->shaderDrawParameters);
4130 }
4131 
4132 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)4133 vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
4134 {
4135     VkStructureType stype;
4136     vn_decode_VkStructureType(dec, &stype);
4137     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
4138 
4139     assert(val->sType == stype);
4140     vn_decode_VkPhysicalDeviceVulkan11Features_pnext(dec, val->pNext);
4141     vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, val);
4142 }
4143 
4144 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void * val)4145 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void *val)
4146 {
4147     /* no known/supported struct */
4148     return vn_sizeof_simple_pointer(NULL);
4149 }
4150 
4151 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features * val)4152 vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features *val)
4153 {
4154     size_t size = 0;
4155     /* skip val->{sType,pNext} */
4156     /* skip val->storageBuffer16BitAccess */
4157     /* skip val->uniformAndStorageBuffer16BitAccess */
4158     /* skip val->storagePushConstant16 */
4159     /* skip val->storageInputOutput16 */
4160     /* skip val->multiview */
4161     /* skip val->multiviewGeometryShader */
4162     /* skip val->multiviewTessellationShader */
4163     /* skip val->variablePointersStorageBuffer */
4164     /* skip val->variablePointers */
4165     /* skip val->protectedMemory */
4166     /* skip val->samplerYcbcrConversion */
4167     /* skip val->shaderDrawParameters */
4168     return size;
4169 }
4170 
4171 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features * val)4172 vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features *val)
4173 {
4174     size_t size = 0;
4175 
4176     size += vn_sizeof_VkStructureType(&val->sType);
4177     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(val->pNext);
4178     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(val);
4179 
4180     return size;
4181 }
4182 
4183 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)4184 vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4185 {
4186     /* no known/supported struct */
4187     vn_encode_simple_pointer(enc, NULL);
4188 }
4189 
4190 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4191 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4192 {
4193     /* skip val->{sType,pNext} */
4194     /* skip val->storageBuffer16BitAccess */
4195     /* skip val->uniformAndStorageBuffer16BitAccess */
4196     /* skip val->storagePushConstant16 */
4197     /* skip val->storageInputOutput16 */
4198     /* skip val->multiview */
4199     /* skip val->multiviewGeometryShader */
4200     /* skip val->multiviewTessellationShader */
4201     /* skip val->variablePointersStorageBuffer */
4202     /* skip val->variablePointers */
4203     /* skip val->protectedMemory */
4204     /* skip val->samplerYcbcrConversion */
4205     /* skip val->shaderDrawParameters */
4206 }
4207 
4208 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)4209 vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
4210 {
4211     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
4212     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
4213     vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(enc, val->pNext);
4214     vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, val);
4215 }
4216 
4217 /* struct VkPhysicalDeviceVulkan12Features chain */
4218 
4219 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void * val)4220 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void *val)
4221 {
4222     /* no known/supported struct */
4223     return vn_sizeof_simple_pointer(NULL);
4224 }
4225 
4226 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features * val)4227 vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features *val)
4228 {
4229     size_t size = 0;
4230     /* skip val->{sType,pNext} */
4231     size += vn_sizeof_VkBool32(&val->samplerMirrorClampToEdge);
4232     size += vn_sizeof_VkBool32(&val->drawIndirectCount);
4233     size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
4234     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
4235     size += vn_sizeof_VkBool32(&val->storagePushConstant8);
4236     size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
4237     size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
4238     size += vn_sizeof_VkBool32(&val->shaderFloat16);
4239     size += vn_sizeof_VkBool32(&val->shaderInt8);
4240     size += vn_sizeof_VkBool32(&val->descriptorIndexing);
4241     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
4242     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
4243     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
4244     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
4245     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
4246     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
4247     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
4248     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
4249     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
4250     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
4251     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
4252     size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
4253     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
4254     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
4255     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
4256     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
4257     size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
4258     size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
4259     size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
4260     size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
4261     size += vn_sizeof_VkBool32(&val->samplerFilterMinmax);
4262     size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
4263     size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
4264     size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
4265     size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
4266     size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
4267     size += vn_sizeof_VkBool32(&val->hostQueryReset);
4268     size += vn_sizeof_VkBool32(&val->timelineSemaphore);
4269     size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
4270     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
4271     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
4272     size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
4273     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
4274     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
4275     size += vn_sizeof_VkBool32(&val->shaderOutputViewportIndex);
4276     size += vn_sizeof_VkBool32(&val->shaderOutputLayer);
4277     size += vn_sizeof_VkBool32(&val->subgroupBroadcastDynamicId);
4278     return size;
4279 }
4280 
4281 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * val)4282 vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *val)
4283 {
4284     size_t size = 0;
4285 
4286     size += vn_sizeof_VkStructureType(&val->sType);
4287     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(val->pNext);
4288     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self(val);
4289 
4290     return size;
4291 }
4292 
4293 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder * enc,const void * val)4294 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val)
4295 {
4296     /* no known/supported struct */
4297     vn_encode_simple_pointer(enc, NULL);
4298 }
4299 
4300 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4301 vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4302 {
4303     /* skip val->{sType,pNext} */
4304     vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge);
4305     vn_encode_VkBool32(enc, &val->drawIndirectCount);
4306     vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
4307     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
4308     vn_encode_VkBool32(enc, &val->storagePushConstant8);
4309     vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
4310     vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
4311     vn_encode_VkBool32(enc, &val->shaderFloat16);
4312     vn_encode_VkBool32(enc, &val->shaderInt8);
4313     vn_encode_VkBool32(enc, &val->descriptorIndexing);
4314     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
4315     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
4316     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
4317     vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
4318     vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
4319     vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
4320     vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
4321     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
4322     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
4323     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
4324     vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
4325     vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
4326     vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
4327     vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
4328     vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
4329     vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
4330     vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
4331     vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
4332     vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
4333     vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
4334     vn_encode_VkBool32(enc, &val->samplerFilterMinmax);
4335     vn_encode_VkBool32(enc, &val->scalarBlockLayout);
4336     vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
4337     vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
4338     vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
4339     vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
4340     vn_encode_VkBool32(enc, &val->hostQueryReset);
4341     vn_encode_VkBool32(enc, &val->timelineSemaphore);
4342     vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
4343     vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
4344     vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
4345     vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
4346     vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
4347     vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
4348     vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex);
4349     vn_encode_VkBool32(enc, &val->shaderOutputLayer);
4350     vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId);
4351 }
4352 
4353 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4354 vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4355 {
4356     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
4357     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
4358     vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext);
4359     vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val);
4360 }
4361 
4362 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder * dec,const void * val)4363 vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder *dec, const void *val)
4364 {
4365     /* no known/supported struct */
4366     if (vn_decode_simple_pointer(dec))
4367         assert(false);
4368 }
4369 
4370 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)4371 vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
4372 {
4373     /* skip val->{sType,pNext} */
4374     vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge);
4375     vn_decode_VkBool32(dec, &val->drawIndirectCount);
4376     vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
4377     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
4378     vn_decode_VkBool32(dec, &val->storagePushConstant8);
4379     vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
4380     vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
4381     vn_decode_VkBool32(dec, &val->shaderFloat16);
4382     vn_decode_VkBool32(dec, &val->shaderInt8);
4383     vn_decode_VkBool32(dec, &val->descriptorIndexing);
4384     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
4385     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
4386     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
4387     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
4388     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
4389     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
4390     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
4391     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
4392     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
4393     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
4394     vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
4395     vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
4396     vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
4397     vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
4398     vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
4399     vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
4400     vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
4401     vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
4402     vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
4403     vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
4404     vn_decode_VkBool32(dec, &val->samplerFilterMinmax);
4405     vn_decode_VkBool32(dec, &val->scalarBlockLayout);
4406     vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
4407     vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
4408     vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
4409     vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
4410     vn_decode_VkBool32(dec, &val->hostQueryReset);
4411     vn_decode_VkBool32(dec, &val->timelineSemaphore);
4412     vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
4413     vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
4414     vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
4415     vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
4416     vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
4417     vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
4418     vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex);
4419     vn_decode_VkBool32(dec, &val->shaderOutputLayer);
4420     vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId);
4421 }
4422 
4423 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)4424 vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
4425 {
4426     VkStructureType stype;
4427     vn_decode_VkStructureType(dec, &stype);
4428     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
4429 
4430     assert(val->sType == stype);
4431     vn_decode_VkPhysicalDeviceVulkan12Features_pnext(dec, val->pNext);
4432     vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, val);
4433 }
4434 
4435 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void * val)4436 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void *val)
4437 {
4438     /* no known/supported struct */
4439     return vn_sizeof_simple_pointer(NULL);
4440 }
4441 
4442 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features * val)4443 vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features *val)
4444 {
4445     size_t size = 0;
4446     /* skip val->{sType,pNext} */
4447     /* skip val->samplerMirrorClampToEdge */
4448     /* skip val->drawIndirectCount */
4449     /* skip val->storageBuffer8BitAccess */
4450     /* skip val->uniformAndStorageBuffer8BitAccess */
4451     /* skip val->storagePushConstant8 */
4452     /* skip val->shaderBufferInt64Atomics */
4453     /* skip val->shaderSharedInt64Atomics */
4454     /* skip val->shaderFloat16 */
4455     /* skip val->shaderInt8 */
4456     /* skip val->descriptorIndexing */
4457     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
4458     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
4459     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
4460     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
4461     /* skip val->shaderSampledImageArrayNonUniformIndexing */
4462     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
4463     /* skip val->shaderStorageImageArrayNonUniformIndexing */
4464     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
4465     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
4466     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
4467     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
4468     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
4469     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
4470     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
4471     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
4472     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
4473     /* skip val->descriptorBindingUpdateUnusedWhilePending */
4474     /* skip val->descriptorBindingPartiallyBound */
4475     /* skip val->descriptorBindingVariableDescriptorCount */
4476     /* skip val->runtimeDescriptorArray */
4477     /* skip val->samplerFilterMinmax */
4478     /* skip val->scalarBlockLayout */
4479     /* skip val->imagelessFramebuffer */
4480     /* skip val->uniformBufferStandardLayout */
4481     /* skip val->shaderSubgroupExtendedTypes */
4482     /* skip val->separateDepthStencilLayouts */
4483     /* skip val->hostQueryReset */
4484     /* skip val->timelineSemaphore */
4485     /* skip val->bufferDeviceAddress */
4486     /* skip val->bufferDeviceAddressCaptureReplay */
4487     /* skip val->bufferDeviceAddressMultiDevice */
4488     /* skip val->vulkanMemoryModel */
4489     /* skip val->vulkanMemoryModelDeviceScope */
4490     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
4491     /* skip val->shaderOutputViewportIndex */
4492     /* skip val->shaderOutputLayer */
4493     /* skip val->subgroupBroadcastDynamicId */
4494     return size;
4495 }
4496 
4497 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features * val)4498 vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features *val)
4499 {
4500     size_t size = 0;
4501 
4502     size += vn_sizeof_VkStructureType(&val->sType);
4503     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(val->pNext);
4504     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(val);
4505 
4506     return size;
4507 }
4508 
4509 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)4510 vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4511 {
4512     /* no known/supported struct */
4513     vn_encode_simple_pointer(enc, NULL);
4514 }
4515 
4516 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4517 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4518 {
4519     /* skip val->{sType,pNext} */
4520     /* skip val->samplerMirrorClampToEdge */
4521     /* skip val->drawIndirectCount */
4522     /* skip val->storageBuffer8BitAccess */
4523     /* skip val->uniformAndStorageBuffer8BitAccess */
4524     /* skip val->storagePushConstant8 */
4525     /* skip val->shaderBufferInt64Atomics */
4526     /* skip val->shaderSharedInt64Atomics */
4527     /* skip val->shaderFloat16 */
4528     /* skip val->shaderInt8 */
4529     /* skip val->descriptorIndexing */
4530     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
4531     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
4532     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
4533     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
4534     /* skip val->shaderSampledImageArrayNonUniformIndexing */
4535     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
4536     /* skip val->shaderStorageImageArrayNonUniformIndexing */
4537     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
4538     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
4539     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
4540     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
4541     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
4542     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
4543     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
4544     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
4545     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
4546     /* skip val->descriptorBindingUpdateUnusedWhilePending */
4547     /* skip val->descriptorBindingPartiallyBound */
4548     /* skip val->descriptorBindingVariableDescriptorCount */
4549     /* skip val->runtimeDescriptorArray */
4550     /* skip val->samplerFilterMinmax */
4551     /* skip val->scalarBlockLayout */
4552     /* skip val->imagelessFramebuffer */
4553     /* skip val->uniformBufferStandardLayout */
4554     /* skip val->shaderSubgroupExtendedTypes */
4555     /* skip val->separateDepthStencilLayouts */
4556     /* skip val->hostQueryReset */
4557     /* skip val->timelineSemaphore */
4558     /* skip val->bufferDeviceAddress */
4559     /* skip val->bufferDeviceAddressCaptureReplay */
4560     /* skip val->bufferDeviceAddressMultiDevice */
4561     /* skip val->vulkanMemoryModel */
4562     /* skip val->vulkanMemoryModelDeviceScope */
4563     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
4564     /* skip val->shaderOutputViewportIndex */
4565     /* skip val->shaderOutputLayer */
4566     /* skip val->subgroupBroadcastDynamicId */
4567 }
4568 
4569 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)4570 vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
4571 {
4572     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
4573     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
4574     vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(enc, val->pNext);
4575     vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val);
4576 }
4577 
4578 /* struct VkPhysicalDeviceFeatures2 chain */
4579 
4580 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void * val)4581 vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val)
4582 {
4583     const VkBaseInStructure *pnext = val;
4584     size_t size = 0;
4585 
4586     while (pnext) {
4587         switch ((int32_t)pnext->sType) {
4588         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4589             size += vn_sizeof_simple_pointer(pnext);
4590             size += vn_sizeof_VkStructureType(&pnext->sType);
4591             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4592             size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
4593             return size;
4594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4595             size += vn_sizeof_simple_pointer(pnext);
4596             size += vn_sizeof_VkStructureType(&pnext->sType);
4597             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4598             size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
4599             return size;
4600         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4601             size += vn_sizeof_simple_pointer(pnext);
4602             size += vn_sizeof_VkStructureType(&pnext->sType);
4603             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4604             size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
4605             return size;
4606         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4607             size += vn_sizeof_simple_pointer(pnext);
4608             size += vn_sizeof_VkStructureType(&pnext->sType);
4609             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4610             size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4611             return size;
4612         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4613             size += vn_sizeof_simple_pointer(pnext);
4614             size += vn_sizeof_VkStructureType(&pnext->sType);
4615             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4616             size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4617             return size;
4618         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4619             size += vn_sizeof_simple_pointer(pnext);
4620             size += vn_sizeof_VkStructureType(&pnext->sType);
4621             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4622             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4623             return size;
4624         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4625             size += vn_sizeof_simple_pointer(pnext);
4626             size += vn_sizeof_VkStructureType(&pnext->sType);
4627             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4628             size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4629             return size;
4630         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4631             size += vn_sizeof_simple_pointer(pnext);
4632             size += vn_sizeof_VkStructureType(&pnext->sType);
4633             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4634             size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4635             return size;
4636         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4637             size += vn_sizeof_simple_pointer(pnext);
4638             size += vn_sizeof_VkStructureType(&pnext->sType);
4639             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4640             size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4641             return size;
4642         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4643             size += vn_sizeof_simple_pointer(pnext);
4644             size += vn_sizeof_VkStructureType(&pnext->sType);
4645             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4646             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4647             return size;
4648         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4649             size += vn_sizeof_simple_pointer(pnext);
4650             size += vn_sizeof_VkStructureType(&pnext->sType);
4651             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4652             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4653             return size;
4654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4655             size += vn_sizeof_simple_pointer(pnext);
4656             size += vn_sizeof_VkStructureType(&pnext->sType);
4657             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4658             size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
4659             return size;
4660         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4661             size += vn_sizeof_simple_pointer(pnext);
4662             size += vn_sizeof_VkStructureType(&pnext->sType);
4663             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4664             size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4665             return size;
4666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4667             size += vn_sizeof_simple_pointer(pnext);
4668             size += vn_sizeof_VkStructureType(&pnext->sType);
4669             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4670             size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4671             return size;
4672         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4673             size += vn_sizeof_simple_pointer(pnext);
4674             size += vn_sizeof_VkStructureType(&pnext->sType);
4675             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4676             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4677             return size;
4678         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4679             size += vn_sizeof_simple_pointer(pnext);
4680             size += vn_sizeof_VkStructureType(&pnext->sType);
4681             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4682             size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4683             return size;
4684         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4685             size += vn_sizeof_simple_pointer(pnext);
4686             size += vn_sizeof_VkStructureType(&pnext->sType);
4687             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4688             size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4689             return size;
4690         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4691             size += vn_sizeof_simple_pointer(pnext);
4692             size += vn_sizeof_VkStructureType(&pnext->sType);
4693             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4694             size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4695             return size;
4696         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4697             size += vn_sizeof_simple_pointer(pnext);
4698             size += vn_sizeof_VkStructureType(&pnext->sType);
4699             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4700             size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4701             return size;
4702         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4703             size += vn_sizeof_simple_pointer(pnext);
4704             size += vn_sizeof_VkStructureType(&pnext->sType);
4705             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4706             size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4707             return size;
4708         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4709             size += vn_sizeof_simple_pointer(pnext);
4710             size += vn_sizeof_VkStructureType(&pnext->sType);
4711             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4712             size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
4713             return size;
4714         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4715             size += vn_sizeof_simple_pointer(pnext);
4716             size += vn_sizeof_VkStructureType(&pnext->sType);
4717             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
4718             size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
4719             return size;
4720         default:
4721             /* ignore unknown/unsupported struct */
4722             break;
4723         }
4724         pnext = pnext->pNext;
4725     }
4726 
4727     return vn_sizeof_simple_pointer(NULL);
4728 }
4729 
4730 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 * val)4731 vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 *val)
4732 {
4733     size_t size = 0;
4734     /* skip val->{sType,pNext} */
4735     size += vn_sizeof_VkPhysicalDeviceFeatures(&val->features);
4736     return size;
4737 }
4738 
4739 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * val)4740 vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *val)
4741 {
4742     size_t size = 0;
4743 
4744     size += vn_sizeof_VkStructureType(&val->sType);
4745     size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(val->pNext);
4746     size += vn_sizeof_VkPhysicalDeviceFeatures2_self(val);
4747 
4748     return size;
4749 }
4750 
4751 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder * enc,const void * val)4752 vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val)
4753 {
4754     const VkBaseInStructure *pnext = val;
4755 
4756     while (pnext) {
4757         switch ((int32_t)pnext->sType) {
4758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4759             vn_encode_simple_pointer(enc, pnext);
4760             vn_encode_VkStructureType(enc, &pnext->sType);
4761             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4762             vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
4763             return;
4764         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4765             vn_encode_simple_pointer(enc, pnext);
4766             vn_encode_VkStructureType(enc, &pnext->sType);
4767             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4768             vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
4769             return;
4770         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4771             vn_encode_simple_pointer(enc, pnext);
4772             vn_encode_VkStructureType(enc, &pnext->sType);
4773             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4774             vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
4775             return;
4776         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4777             vn_encode_simple_pointer(enc, pnext);
4778             vn_encode_VkStructureType(enc, &pnext->sType);
4779             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4780             vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4781             return;
4782         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4783             vn_encode_simple_pointer(enc, pnext);
4784             vn_encode_VkStructureType(enc, &pnext->sType);
4785             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4786             vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4787             return;
4788         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4789             vn_encode_simple_pointer(enc, pnext);
4790             vn_encode_VkStructureType(enc, &pnext->sType);
4791             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4792             vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4793             return;
4794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4795             vn_encode_simple_pointer(enc, pnext);
4796             vn_encode_VkStructureType(enc, &pnext->sType);
4797             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4798             vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4799             return;
4800         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4801             vn_encode_simple_pointer(enc, pnext);
4802             vn_encode_VkStructureType(enc, &pnext->sType);
4803             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4804             vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4805             return;
4806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4807             vn_encode_simple_pointer(enc, pnext);
4808             vn_encode_VkStructureType(enc, &pnext->sType);
4809             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4810             vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4811             return;
4812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4813             vn_encode_simple_pointer(enc, pnext);
4814             vn_encode_VkStructureType(enc, &pnext->sType);
4815             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4816             vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4817             return;
4818         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4819             vn_encode_simple_pointer(enc, pnext);
4820             vn_encode_VkStructureType(enc, &pnext->sType);
4821             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4822             vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4823             return;
4824         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4825             vn_encode_simple_pointer(enc, pnext);
4826             vn_encode_VkStructureType(enc, &pnext->sType);
4827             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4828             vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
4829             return;
4830         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4831             vn_encode_simple_pointer(enc, pnext);
4832             vn_encode_VkStructureType(enc, &pnext->sType);
4833             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4834             vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4835             return;
4836         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4837             vn_encode_simple_pointer(enc, pnext);
4838             vn_encode_VkStructureType(enc, &pnext->sType);
4839             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4840             vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4841             return;
4842         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4843             vn_encode_simple_pointer(enc, pnext);
4844             vn_encode_VkStructureType(enc, &pnext->sType);
4845             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4846             vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4847             return;
4848         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4849             vn_encode_simple_pointer(enc, pnext);
4850             vn_encode_VkStructureType(enc, &pnext->sType);
4851             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4852             vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4853             return;
4854         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4855             vn_encode_simple_pointer(enc, pnext);
4856             vn_encode_VkStructureType(enc, &pnext->sType);
4857             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4858             vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
4859             return;
4860         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4861             vn_encode_simple_pointer(enc, pnext);
4862             vn_encode_VkStructureType(enc, &pnext->sType);
4863             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4864             vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
4865             return;
4866         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4867             vn_encode_simple_pointer(enc, pnext);
4868             vn_encode_VkStructureType(enc, &pnext->sType);
4869             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4870             vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
4871             return;
4872         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4873             vn_encode_simple_pointer(enc, pnext);
4874             vn_encode_VkStructureType(enc, &pnext->sType);
4875             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4876             vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
4877             return;
4878         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4879             vn_encode_simple_pointer(enc, pnext);
4880             vn_encode_VkStructureType(enc, &pnext->sType);
4881             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4882             vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
4883             return;
4884         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4885             vn_encode_simple_pointer(enc, pnext);
4886             vn_encode_VkStructureType(enc, &pnext->sType);
4887             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
4888             vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
4889             return;
4890         default:
4891             /* ignore unknown/unsupported struct */
4892             break;
4893         }
4894         pnext = pnext->pNext;
4895     }
4896 
4897     vn_encode_simple_pointer(enc, NULL);
4898 }
4899 
4900 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)4901 vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
4902 {
4903     /* skip val->{sType,pNext} */
4904     vn_encode_VkPhysicalDeviceFeatures(enc, &val->features);
4905 }
4906 
4907 static inline void
vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)4908 vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
4909 {
4910     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
4911     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
4912     vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext);
4913     vn_encode_VkPhysicalDeviceFeatures2_self(enc, val);
4914 }
4915 
4916 static inline void
vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder * dec,const void * val)4917 vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void *val)
4918 {
4919     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
4920     VkStructureType stype;
4921 
4922     if (!vn_decode_simple_pointer(dec))
4923         return;
4924 
4925     vn_decode_VkStructureType(dec, &stype);
4926     while (true) {
4927         assert(pnext);
4928         if (pnext->sType == stype)
4929             break;
4930     }
4931 
4932     switch ((int32_t)pnext->sType) {
4933     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4934         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4935         vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
4936         break;
4937     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4938         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4939         vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
4940         break;
4941     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4942         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4943         vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
4944         break;
4945     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4946         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4947         vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
4948         break;
4949     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4950         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4951         vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
4952         break;
4953     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4954         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4955         vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
4956         break;
4957     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4958         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4959         vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
4960         break;
4961     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4962         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4963         vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
4964         break;
4965     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4966         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4967         vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
4968         break;
4969     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4970         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4971         vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
4972         break;
4973     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4974         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4975         vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
4976         break;
4977     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4978         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4979         vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
4980         break;
4981     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4982         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4983         vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
4984         break;
4985     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4986         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4987         vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
4988         break;
4989     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4990         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4991         vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
4992         break;
4993     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4994         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4995         vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
4996         break;
4997     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4998         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
4999         vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5000         break;
5001     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5002         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5003         vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5004         break;
5005     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5006         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5007         vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5008         break;
5009     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5010         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5011         vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5012         break;
5013     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5014         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5015         vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
5016         break;
5017     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5018         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
5019         vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
5020         break;
5021     default:
5022         assert(false);
5023         break;
5024     }
5025 }
5026 
5027 static inline void
vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)5028 vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
5029 {
5030     /* skip val->{sType,pNext} */
5031     vn_decode_VkPhysicalDeviceFeatures(dec, &val->features);
5032 }
5033 
5034 static inline void
vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)5035 vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
5036 {
5037     VkStructureType stype;
5038     vn_decode_VkStructureType(dec, &stype);
5039     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
5040 
5041     assert(val->sType == stype);
5042     vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, val->pNext);
5043     vn_decode_VkPhysicalDeviceFeatures2_self(dec, val);
5044 }
5045 
5046 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void * val)5047 vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val)
5048 {
5049     const VkBaseInStructure *pnext = val;
5050     size_t size = 0;
5051 
5052     while (pnext) {
5053         switch ((int32_t)pnext->sType) {
5054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5055             size += vn_sizeof_simple_pointer(pnext);
5056             size += vn_sizeof_VkStructureType(&pnext->sType);
5057             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5058             size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5059             return size;
5060         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5061             size += vn_sizeof_simple_pointer(pnext);
5062             size += vn_sizeof_VkStructureType(&pnext->sType);
5063             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5064             size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial((const VkPhysicalDeviceMultiviewFeatures *)pnext);
5065             return size;
5066         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5067             size += vn_sizeof_simple_pointer(pnext);
5068             size += vn_sizeof_VkStructureType(&pnext->sType);
5069             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5070             size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial((const VkPhysicalDevice16BitStorageFeatures *)pnext);
5071             return size;
5072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5073             size += vn_sizeof_simple_pointer(pnext);
5074             size += vn_sizeof_VkStructureType(&pnext->sType);
5075             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5076             size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5077             return size;
5078         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5079             size += vn_sizeof_simple_pointer(pnext);
5080             size += vn_sizeof_VkStructureType(&pnext->sType);
5081             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5082             size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5083             return size;
5084         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5085             size += vn_sizeof_simple_pointer(pnext);
5086             size += vn_sizeof_VkStructureType(&pnext->sType);
5087             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5088             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5089             return size;
5090         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5091             size += vn_sizeof_simple_pointer(pnext);
5092             size += vn_sizeof_VkStructureType(&pnext->sType);
5093             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5094             size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5095             return size;
5096         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5097             size += vn_sizeof_simple_pointer(pnext);
5098             size += vn_sizeof_VkStructureType(&pnext->sType);
5099             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5100             size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5101             return size;
5102         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5103             size += vn_sizeof_simple_pointer(pnext);
5104             size += vn_sizeof_VkStructureType(&pnext->sType);
5105             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5106             size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5107             return size;
5108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5109             size += vn_sizeof_simple_pointer(pnext);
5110             size += vn_sizeof_VkStructureType(&pnext->sType);
5111             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5112             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5113             return size;
5114         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5115             size += vn_sizeof_simple_pointer(pnext);
5116             size += vn_sizeof_VkStructureType(&pnext->sType);
5117             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5118             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5119             return size;
5120         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5121             size += vn_sizeof_simple_pointer(pnext);
5122             size += vn_sizeof_VkStructureType(&pnext->sType);
5123             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5124             size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial((const VkPhysicalDevice8BitStorageFeatures *)pnext);
5125             return size;
5126         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5127             size += vn_sizeof_simple_pointer(pnext);
5128             size += vn_sizeof_VkStructureType(&pnext->sType);
5129             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5130             size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5131             return size;
5132         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5133             size += vn_sizeof_simple_pointer(pnext);
5134             size += vn_sizeof_VkStructureType(&pnext->sType);
5135             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5136             size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5137             return size;
5138         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5139             size += vn_sizeof_simple_pointer(pnext);
5140             size += vn_sizeof_VkStructureType(&pnext->sType);
5141             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5142             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5143             return size;
5144         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5145             size += vn_sizeof_simple_pointer(pnext);
5146             size += vn_sizeof_VkStructureType(&pnext->sType);
5147             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5148             size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5149             return size;
5150         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5151             size += vn_sizeof_simple_pointer(pnext);
5152             size += vn_sizeof_VkStructureType(&pnext->sType);
5153             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5154             size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5155             return size;
5156         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5157             size += vn_sizeof_simple_pointer(pnext);
5158             size += vn_sizeof_VkStructureType(&pnext->sType);
5159             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5160             size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5161             return size;
5162         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5163             size += vn_sizeof_simple_pointer(pnext);
5164             size += vn_sizeof_VkStructureType(&pnext->sType);
5165             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5166             size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5167             return size;
5168         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5169             size += vn_sizeof_simple_pointer(pnext);
5170             size += vn_sizeof_VkStructureType(&pnext->sType);
5171             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5172             size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5173             return size;
5174         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5175             size += vn_sizeof_simple_pointer(pnext);
5176             size += vn_sizeof_VkStructureType(&pnext->sType);
5177             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5178             size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial((const VkPhysicalDeviceVulkan11Features *)pnext);
5179             return size;
5180         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5181             size += vn_sizeof_simple_pointer(pnext);
5182             size += vn_sizeof_VkStructureType(&pnext->sType);
5183             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
5184             size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext);
5185             return size;
5186         default:
5187             /* ignore unknown/unsupported struct */
5188             break;
5189         }
5190         pnext = pnext->pNext;
5191     }
5192 
5193     return vn_sizeof_simple_pointer(NULL);
5194 }
5195 
5196 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 * val)5197 vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 *val)
5198 {
5199     size_t size = 0;
5200     /* skip val->{sType,pNext} */
5201     size += vn_sizeof_VkPhysicalDeviceFeatures_partial(&val->features);
5202     return size;
5203 }
5204 
5205 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 * val)5206 vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 *val)
5207 {
5208     size_t size = 0;
5209 
5210     size += vn_sizeof_VkStructureType(&val->sType);
5211     size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(val->pNext);
5212     size += vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(val);
5213 
5214     return size;
5215 }
5216 
5217 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder * enc,const void * val)5218 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5219 {
5220     const VkBaseInStructure *pnext = val;
5221 
5222     while (pnext) {
5223         switch ((int32_t)pnext->sType) {
5224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5225             vn_encode_simple_pointer(enc, pnext);
5226             vn_encode_VkStructureType(enc, &pnext->sType);
5227             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5228             vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5229             return;
5230         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5231             vn_encode_simple_pointer(enc, pnext);
5232             vn_encode_VkStructureType(enc, &pnext->sType);
5233             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5234             vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
5235             return;
5236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5237             vn_encode_simple_pointer(enc, pnext);
5238             vn_encode_VkStructureType(enc, &pnext->sType);
5239             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5240             vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
5241             return;
5242         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5243             vn_encode_simple_pointer(enc, pnext);
5244             vn_encode_VkStructureType(enc, &pnext->sType);
5245             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5246             vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5247             return;
5248         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5249             vn_encode_simple_pointer(enc, pnext);
5250             vn_encode_VkStructureType(enc, &pnext->sType);
5251             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5252             vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5253             return;
5254         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5255             vn_encode_simple_pointer(enc, pnext);
5256             vn_encode_VkStructureType(enc, &pnext->sType);
5257             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5258             vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5259             return;
5260         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5261             vn_encode_simple_pointer(enc, pnext);
5262             vn_encode_VkStructureType(enc, &pnext->sType);
5263             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5264             vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5265             return;
5266         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5267             vn_encode_simple_pointer(enc, pnext);
5268             vn_encode_VkStructureType(enc, &pnext->sType);
5269             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5270             vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5271             return;
5272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5273             vn_encode_simple_pointer(enc, pnext);
5274             vn_encode_VkStructureType(enc, &pnext->sType);
5275             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5276             vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5277             return;
5278         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5279             vn_encode_simple_pointer(enc, pnext);
5280             vn_encode_VkStructureType(enc, &pnext->sType);
5281             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5282             vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5283             return;
5284         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5285             vn_encode_simple_pointer(enc, pnext);
5286             vn_encode_VkStructureType(enc, &pnext->sType);
5287             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5288             vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5289             return;
5290         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5291             vn_encode_simple_pointer(enc, pnext);
5292             vn_encode_VkStructureType(enc, &pnext->sType);
5293             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5294             vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
5295             return;
5296         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5297             vn_encode_simple_pointer(enc, pnext);
5298             vn_encode_VkStructureType(enc, &pnext->sType);
5299             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5300             vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5301             return;
5302         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5303             vn_encode_simple_pointer(enc, pnext);
5304             vn_encode_VkStructureType(enc, &pnext->sType);
5305             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5306             vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5307             return;
5308         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5309             vn_encode_simple_pointer(enc, pnext);
5310             vn_encode_VkStructureType(enc, &pnext->sType);
5311             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5312             vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5313             return;
5314         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5315             vn_encode_simple_pointer(enc, pnext);
5316             vn_encode_VkStructureType(enc, &pnext->sType);
5317             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5318             vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5319             return;
5320         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5321             vn_encode_simple_pointer(enc, pnext);
5322             vn_encode_VkStructureType(enc, &pnext->sType);
5323             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5324             vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5325             return;
5326         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5327             vn_encode_simple_pointer(enc, pnext);
5328             vn_encode_VkStructureType(enc, &pnext->sType);
5329             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5330             vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5331             return;
5332         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5333             vn_encode_simple_pointer(enc, pnext);
5334             vn_encode_VkStructureType(enc, &pnext->sType);
5335             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5336             vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5337             return;
5338         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5339             vn_encode_simple_pointer(enc, pnext);
5340             vn_encode_VkStructureType(enc, &pnext->sType);
5341             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5342             vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5343             return;
5344         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5345             vn_encode_simple_pointer(enc, pnext);
5346             vn_encode_VkStructureType(enc, &pnext->sType);
5347             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5348             vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
5349             return;
5350         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5351             vn_encode_simple_pointer(enc, pnext);
5352             vn_encode_VkStructureType(enc, &pnext->sType);
5353             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
5354             vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
5355             return;
5356         default:
5357             /* ignore unknown/unsupported struct */
5358             break;
5359         }
5360         pnext = pnext->pNext;
5361     }
5362 
5363     vn_encode_simple_pointer(enc, NULL);
5364 }
5365 
5366 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)5367 vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
5368 {
5369     /* skip val->{sType,pNext} */
5370     vn_encode_VkPhysicalDeviceFeatures_partial(enc, &val->features);
5371 }
5372 
5373 static inline void
vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)5374 vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
5375 {
5376     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
5377     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
5378     vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, val->pNext);
5379     vn_encode_VkPhysicalDeviceFeatures2_self_partial(enc, val);
5380 }
5381 
5382 /* struct VkDeviceGroupDeviceCreateInfo chain */
5383 
5384 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void * val)5385 vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void *val)
5386 {
5387     /* no known/supported struct */
5388     return vn_sizeof_simple_pointer(NULL);
5389 }
5390 
5391 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo * val)5392 vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo *val)
5393 {
5394     size_t size = 0;
5395     /* skip val->{sType,pNext} */
5396     size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
5397     if (val->pPhysicalDevices) {
5398         size += vn_sizeof_array_size(val->physicalDeviceCount);
5399         for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
5400             size += vn_sizeof_VkPhysicalDevice(&val->pPhysicalDevices[i]);
5401     } else {
5402         size += vn_sizeof_array_size(0);
5403     }
5404     return size;
5405 }
5406 
5407 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * val)5408 vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *val)
5409 {
5410     size_t size = 0;
5411 
5412     size += vn_sizeof_VkStructureType(&val->sType);
5413     size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(val->pNext);
5414     size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(val);
5415 
5416     return size;
5417 }
5418 
5419 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)5420 vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
5421 {
5422     /* no known/supported struct */
5423     vn_encode_simple_pointer(enc, NULL);
5424 }
5425 
5426 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)5427 vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
5428 {
5429     /* skip val->{sType,pNext} */
5430     vn_encode_uint32_t(enc, &val->physicalDeviceCount);
5431     if (val->pPhysicalDevices) {
5432         vn_encode_array_size(enc, val->physicalDeviceCount);
5433         for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
5434             vn_encode_VkPhysicalDevice(enc, &val->pPhysicalDevices[i]);
5435     } else {
5436         vn_encode_array_size(enc, 0);
5437     }
5438 }
5439 
5440 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)5441 vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
5442 {
5443     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
5444     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO });
5445     vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(enc, val->pNext);
5446     vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, val);
5447 }
5448 
5449 /* struct VkDeviceCreateInfo chain */
5450 
5451 static inline size_t
vn_sizeof_VkDeviceCreateInfo_pnext(const void * val)5452 vn_sizeof_VkDeviceCreateInfo_pnext(const void *val)
5453 {
5454     const VkBaseInStructure *pnext = val;
5455     size_t size = 0;
5456 
5457     while (pnext) {
5458         switch ((int32_t)pnext->sType) {
5459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
5460             size += vn_sizeof_simple_pointer(pnext);
5461             size += vn_sizeof_VkStructureType(&pnext->sType);
5462             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5463             size += vn_sizeof_VkPhysicalDeviceFeatures2_self((const VkPhysicalDeviceFeatures2 *)pnext);
5464             return size;
5465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5466             size += vn_sizeof_simple_pointer(pnext);
5467             size += vn_sizeof_VkStructureType(&pnext->sType);
5468             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5469             size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5470             return size;
5471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5472             size += vn_sizeof_simple_pointer(pnext);
5473             size += vn_sizeof_VkStructureType(&pnext->sType);
5474             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5475             size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
5476             return size;
5477         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
5478             size += vn_sizeof_simple_pointer(pnext);
5479             size += vn_sizeof_VkStructureType(&pnext->sType);
5480             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5481             size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self((const VkDeviceGroupDeviceCreateInfo *)pnext);
5482             return size;
5483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5484             size += vn_sizeof_simple_pointer(pnext);
5485             size += vn_sizeof_VkStructureType(&pnext->sType);
5486             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5487             size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
5488             return size;
5489         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5490             size += vn_sizeof_simple_pointer(pnext);
5491             size += vn_sizeof_VkStructureType(&pnext->sType);
5492             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5493             size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5494             return size;
5495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5496             size += vn_sizeof_simple_pointer(pnext);
5497             size += vn_sizeof_VkStructureType(&pnext->sType);
5498             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5499             size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5500             return size;
5501         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5502             size += vn_sizeof_simple_pointer(pnext);
5503             size += vn_sizeof_VkStructureType(&pnext->sType);
5504             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5505             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5506             return size;
5507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5508             size += vn_sizeof_simple_pointer(pnext);
5509             size += vn_sizeof_VkStructureType(&pnext->sType);
5510             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5511             size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5512             return size;
5513         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5514             size += vn_sizeof_simple_pointer(pnext);
5515             size += vn_sizeof_VkStructureType(&pnext->sType);
5516             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5517             size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5518             return size;
5519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5520             size += vn_sizeof_simple_pointer(pnext);
5521             size += vn_sizeof_VkStructureType(&pnext->sType);
5522             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5523             size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5524             return size;
5525         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5526             size += vn_sizeof_simple_pointer(pnext);
5527             size += vn_sizeof_VkStructureType(&pnext->sType);
5528             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5529             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5530             return size;
5531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5532             size += vn_sizeof_simple_pointer(pnext);
5533             size += vn_sizeof_VkStructureType(&pnext->sType);
5534             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5535             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5536             return size;
5537         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5538             size += vn_sizeof_simple_pointer(pnext);
5539             size += vn_sizeof_VkStructureType(&pnext->sType);
5540             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5541             size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
5542             return size;
5543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5544             size += vn_sizeof_simple_pointer(pnext);
5545             size += vn_sizeof_VkStructureType(&pnext->sType);
5546             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5547             size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5548             return size;
5549         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5550             size += vn_sizeof_simple_pointer(pnext);
5551             size += vn_sizeof_VkStructureType(&pnext->sType);
5552             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5553             size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5554             return size;
5555         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5556             size += vn_sizeof_simple_pointer(pnext);
5557             size += vn_sizeof_VkStructureType(&pnext->sType);
5558             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5559             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5560             return size;
5561         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5562             size += vn_sizeof_simple_pointer(pnext);
5563             size += vn_sizeof_VkStructureType(&pnext->sType);
5564             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5565             size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5566             return size;
5567         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5568             size += vn_sizeof_simple_pointer(pnext);
5569             size += vn_sizeof_VkStructureType(&pnext->sType);
5570             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5571             size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5572             return size;
5573         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5574             size += vn_sizeof_simple_pointer(pnext);
5575             size += vn_sizeof_VkStructureType(&pnext->sType);
5576             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5577             size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5578             return size;
5579         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5580             size += vn_sizeof_simple_pointer(pnext);
5581             size += vn_sizeof_VkStructureType(&pnext->sType);
5582             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5583             size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5584             return size;
5585         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5586             size += vn_sizeof_simple_pointer(pnext);
5587             size += vn_sizeof_VkStructureType(&pnext->sType);
5588             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5589             size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5590             return size;
5591         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5592             size += vn_sizeof_simple_pointer(pnext);
5593             size += vn_sizeof_VkStructureType(&pnext->sType);
5594             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5595             size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
5596             return size;
5597         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5598             size += vn_sizeof_simple_pointer(pnext);
5599             size += vn_sizeof_VkStructureType(&pnext->sType);
5600             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
5601             size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
5602             return size;
5603         default:
5604             /* ignore unknown/unsupported struct */
5605             break;
5606         }
5607         pnext = pnext->pNext;
5608     }
5609 
5610     return vn_sizeof_simple_pointer(NULL);
5611 }
5612 
5613 static inline size_t
vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo * val)5614 vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo *val)
5615 {
5616     size_t size = 0;
5617     /* skip val->{sType,pNext} */
5618     size += vn_sizeof_VkFlags(&val->flags);
5619     size += vn_sizeof_uint32_t(&val->queueCreateInfoCount);
5620     if (val->pQueueCreateInfos) {
5621         size += vn_sizeof_array_size(val->queueCreateInfoCount);
5622         for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
5623             size += vn_sizeof_VkDeviceQueueCreateInfo(&val->pQueueCreateInfos[i]);
5624     } else {
5625         size += vn_sizeof_array_size(0);
5626     }
5627     size += vn_sizeof_uint32_t(&val->enabledLayerCount);
5628     if (val->ppEnabledLayerNames) {
5629         size += vn_sizeof_array_size(val->enabledLayerCount);
5630         for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
5631             const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
5632             size += vn_sizeof_array_size(string_size);
5633             size += vn_sizeof_char_array(val->ppEnabledLayerNames[i], string_size);
5634         }
5635     } else {
5636         size += vn_sizeof_array_size(0);
5637     }
5638     size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
5639     if (val->ppEnabledExtensionNames) {
5640         size += vn_sizeof_array_size(val->enabledExtensionCount);
5641         for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
5642             const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
5643             size += vn_sizeof_array_size(string_size);
5644             size += vn_sizeof_char_array(val->ppEnabledExtensionNames[i], string_size);
5645         }
5646     } else {
5647         size += vn_sizeof_array_size(0);
5648     }
5649     size += vn_sizeof_simple_pointer(val->pEnabledFeatures);
5650     if (val->pEnabledFeatures)
5651         size += vn_sizeof_VkPhysicalDeviceFeatures(val->pEnabledFeatures);
5652     return size;
5653 }
5654 
5655 static inline size_t
vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo * val)5656 vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo *val)
5657 {
5658     size_t size = 0;
5659 
5660     size += vn_sizeof_VkStructureType(&val->sType);
5661     size += vn_sizeof_VkDeviceCreateInfo_pnext(val->pNext);
5662     size += vn_sizeof_VkDeviceCreateInfo_self(val);
5663 
5664     return size;
5665 }
5666 
5667 static inline void
vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)5668 vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
5669 {
5670     const VkBaseInStructure *pnext = val;
5671 
5672     while (pnext) {
5673         switch ((int32_t)pnext->sType) {
5674         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
5675             vn_encode_simple_pointer(enc, pnext);
5676             vn_encode_VkStructureType(enc, &pnext->sType);
5677             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5678             vn_encode_VkPhysicalDeviceFeatures2_self(enc, (const VkPhysicalDeviceFeatures2 *)pnext);
5679             return;
5680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5681             vn_encode_simple_pointer(enc, pnext);
5682             vn_encode_VkStructureType(enc, &pnext->sType);
5683             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5684             vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
5685             return;
5686         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5687             vn_encode_simple_pointer(enc, pnext);
5688             vn_encode_VkStructureType(enc, &pnext->sType);
5689             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5690             vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
5691             return;
5692         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
5693             vn_encode_simple_pointer(enc, pnext);
5694             vn_encode_VkStructureType(enc, &pnext->sType);
5695             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5696             vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, (const VkDeviceGroupDeviceCreateInfo *)pnext);
5697             return;
5698         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5699             vn_encode_simple_pointer(enc, pnext);
5700             vn_encode_VkStructureType(enc, &pnext->sType);
5701             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5702             vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
5703             return;
5704         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5705             vn_encode_simple_pointer(enc, pnext);
5706             vn_encode_VkStructureType(enc, &pnext->sType);
5707             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5708             vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
5709             return;
5710         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5711             vn_encode_simple_pointer(enc, pnext);
5712             vn_encode_VkStructureType(enc, &pnext->sType);
5713             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5714             vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
5715             return;
5716         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5717             vn_encode_simple_pointer(enc, pnext);
5718             vn_encode_VkStructureType(enc, &pnext->sType);
5719             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5720             vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
5721             return;
5722         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5723             vn_encode_simple_pointer(enc, pnext);
5724             vn_encode_VkStructureType(enc, &pnext->sType);
5725             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5726             vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
5727             return;
5728         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5729             vn_encode_simple_pointer(enc, pnext);
5730             vn_encode_VkStructureType(enc, &pnext->sType);
5731             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5732             vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
5733             return;
5734         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
5735             vn_encode_simple_pointer(enc, pnext);
5736             vn_encode_VkStructureType(enc, &pnext->sType);
5737             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5738             vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
5739             return;
5740         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
5741             vn_encode_simple_pointer(enc, pnext);
5742             vn_encode_VkStructureType(enc, &pnext->sType);
5743             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5744             vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
5745             return;
5746         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
5747             vn_encode_simple_pointer(enc, pnext);
5748             vn_encode_VkStructureType(enc, &pnext->sType);
5749             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5750             vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
5751             return;
5752         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
5753             vn_encode_simple_pointer(enc, pnext);
5754             vn_encode_VkStructureType(enc, &pnext->sType);
5755             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5756             vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
5757             return;
5758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
5759             vn_encode_simple_pointer(enc, pnext);
5760             vn_encode_VkStructureType(enc, &pnext->sType);
5761             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5762             vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
5763             return;
5764         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
5765             vn_encode_simple_pointer(enc, pnext);
5766             vn_encode_VkStructureType(enc, &pnext->sType);
5767             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5768             vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
5769             return;
5770         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
5771             vn_encode_simple_pointer(enc, pnext);
5772             vn_encode_VkStructureType(enc, &pnext->sType);
5773             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5774             vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
5775             return;
5776         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
5777             vn_encode_simple_pointer(enc, pnext);
5778             vn_encode_VkStructureType(enc, &pnext->sType);
5779             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5780             vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
5781             return;
5782         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
5783             vn_encode_simple_pointer(enc, pnext);
5784             vn_encode_VkStructureType(enc, &pnext->sType);
5785             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5786             vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
5787             return;
5788         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
5789             vn_encode_simple_pointer(enc, pnext);
5790             vn_encode_VkStructureType(enc, &pnext->sType);
5791             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5792             vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
5793             return;
5794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
5795             vn_encode_simple_pointer(enc, pnext);
5796             vn_encode_VkStructureType(enc, &pnext->sType);
5797             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5798             vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
5799             return;
5800         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
5801             vn_encode_simple_pointer(enc, pnext);
5802             vn_encode_VkStructureType(enc, &pnext->sType);
5803             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5804             vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
5805             return;
5806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
5807             vn_encode_simple_pointer(enc, pnext);
5808             vn_encode_VkStructureType(enc, &pnext->sType);
5809             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5810             vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
5811             return;
5812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
5813             vn_encode_simple_pointer(enc, pnext);
5814             vn_encode_VkStructureType(enc, &pnext->sType);
5815             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
5816             vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
5817             return;
5818         default:
5819             /* ignore unknown/unsupported struct */
5820             break;
5821         }
5822         pnext = pnext->pNext;
5823     }
5824 
5825     vn_encode_simple_pointer(enc, NULL);
5826 }
5827 
5828 static inline void
vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)5829 vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
5830 {
5831     /* skip val->{sType,pNext} */
5832     vn_encode_VkFlags(enc, &val->flags);
5833     vn_encode_uint32_t(enc, &val->queueCreateInfoCount);
5834     if (val->pQueueCreateInfos) {
5835         vn_encode_array_size(enc, val->queueCreateInfoCount);
5836         for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
5837             vn_encode_VkDeviceQueueCreateInfo(enc, &val->pQueueCreateInfos[i]);
5838     } else {
5839         vn_encode_array_size(enc, 0);
5840     }
5841     vn_encode_uint32_t(enc, &val->enabledLayerCount);
5842     if (val->ppEnabledLayerNames) {
5843         vn_encode_array_size(enc, val->enabledLayerCount);
5844         for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
5845             const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
5846             vn_encode_array_size(enc, string_size);
5847             vn_encode_char_array(enc, val->ppEnabledLayerNames[i], string_size);
5848         }
5849     } else {
5850         vn_encode_array_size(enc, 0);
5851     }
5852     vn_encode_uint32_t(enc, &val->enabledExtensionCount);
5853     if (val->ppEnabledExtensionNames) {
5854         vn_encode_array_size(enc, val->enabledExtensionCount);
5855         for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
5856             const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
5857             vn_encode_array_size(enc, string_size);
5858             vn_encode_char_array(enc, val->ppEnabledExtensionNames[i], string_size);
5859         }
5860     } else {
5861         vn_encode_array_size(enc, 0);
5862     }
5863     if (vn_encode_simple_pointer(enc, val->pEnabledFeatures))
5864         vn_encode_VkPhysicalDeviceFeatures(enc, val->pEnabledFeatures);
5865 }
5866 
5867 static inline void
vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)5868 vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
5869 {
5870     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
5871     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO });
5872     vn_encode_VkDeviceCreateInfo_pnext(enc, val->pNext);
5873     vn_encode_VkDeviceCreateInfo_self(enc, val);
5874 }
5875 
5876 /* struct VkConformanceVersion */
5877 
5878 static inline size_t
vn_sizeof_VkConformanceVersion(const VkConformanceVersion * val)5879 vn_sizeof_VkConformanceVersion(const VkConformanceVersion *val)
5880 {
5881     size_t size = 0;
5882     size += vn_sizeof_uint8_t(&val->major);
5883     size += vn_sizeof_uint8_t(&val->minor);
5884     size += vn_sizeof_uint8_t(&val->subminor);
5885     size += vn_sizeof_uint8_t(&val->patch);
5886     return size;
5887 }
5888 
5889 static inline void
vn_decode_VkConformanceVersion(struct vn_cs_decoder * dec,VkConformanceVersion * val)5890 vn_decode_VkConformanceVersion(struct vn_cs_decoder *dec, VkConformanceVersion *val)
5891 {
5892     vn_decode_uint8_t(dec, &val->major);
5893     vn_decode_uint8_t(dec, &val->minor);
5894     vn_decode_uint8_t(dec, &val->subminor);
5895     vn_decode_uint8_t(dec, &val->patch);
5896 }
5897 
5898 static inline size_t
vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion * val)5899 vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion *val)
5900 {
5901     size_t size = 0;
5902     /* skip val->major */
5903     /* skip val->minor */
5904     /* skip val->subminor */
5905     /* skip val->patch */
5906     return size;
5907 }
5908 
5909 static inline void
vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder * enc,const VkConformanceVersion * val)5910 vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder *enc, const VkConformanceVersion *val)
5911 {
5912     /* skip val->major */
5913     /* skip val->minor */
5914     /* skip val->subminor */
5915     /* skip val->patch */
5916 }
5917 
5918 /* struct VkPhysicalDeviceDriverProperties chain */
5919 
5920 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void * val)5921 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void *val)
5922 {
5923     /* no known/supported struct */
5924     return vn_sizeof_simple_pointer(NULL);
5925 }
5926 
5927 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties * val)5928 vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties *val)
5929 {
5930     size_t size = 0;
5931     /* skip val->{sType,pNext} */
5932     size += vn_sizeof_VkDriverId(&val->driverID);
5933     size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
5934     size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
5935     size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
5936     size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
5937     size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
5938     return size;
5939 }
5940 
5941 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * val)5942 vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *val)
5943 {
5944     size_t size = 0;
5945 
5946     size += vn_sizeof_VkStructureType(&val->sType);
5947     size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(val->pNext);
5948     size += vn_sizeof_VkPhysicalDeviceDriverProperties_self(val);
5949 
5950     return size;
5951 }
5952 
5953 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder * dec,const void * val)5954 vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder *dec, const void *val)
5955 {
5956     /* no known/supported struct */
5957     if (vn_decode_simple_pointer(dec))
5958         assert(false);
5959 }
5960 
5961 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)5962 vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
5963 {
5964     /* skip val->{sType,pNext} */
5965     vn_decode_VkDriverId(dec, &val->driverID);
5966     {
5967         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
5968         vn_decode_char_array(dec, val->driverName, array_size);
5969     }
5970     {
5971         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
5972         vn_decode_char_array(dec, val->driverInfo, array_size);
5973     }
5974     vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
5975 }
5976 
5977 static inline void
vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)5978 vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
5979 {
5980     VkStructureType stype;
5981     vn_decode_VkStructureType(dec, &stype);
5982     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
5983 
5984     assert(val->sType == stype);
5985     vn_decode_VkPhysicalDeviceDriverProperties_pnext(dec, val->pNext);
5986     vn_decode_VkPhysicalDeviceDriverProperties_self(dec, val);
5987 }
5988 
5989 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void * val)5990 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void *val)
5991 {
5992     /* no known/supported struct */
5993     return vn_sizeof_simple_pointer(NULL);
5994 }
5995 
5996 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties * val)5997 vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties *val)
5998 {
5999     size_t size = 0;
6000     /* skip val->{sType,pNext} */
6001     /* skip val->driverID */
6002     /* skip val->driverName */
6003     /* skip val->driverInfo */
6004     size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
6005     return size;
6006 }
6007 
6008 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties * val)6009 vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties *val)
6010 {
6011     size_t size = 0;
6012 
6013     size += vn_sizeof_VkStructureType(&val->sType);
6014     size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(val->pNext);
6015     size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(val);
6016 
6017     return size;
6018 }
6019 
6020 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6021 vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6022 {
6023     /* no known/supported struct */
6024     vn_encode_simple_pointer(enc, NULL);
6025 }
6026 
6027 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)6028 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
6029 {
6030     /* skip val->{sType,pNext} */
6031     /* skip val->driverID */
6032     /* skip val->driverName */
6033     /* skip val->driverInfo */
6034     vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
6035 }
6036 
6037 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)6038 vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
6039 {
6040     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
6041     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES });
6042     vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(enc, val->pNext);
6043     vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, val);
6044 }
6045 
6046 /* struct VkPhysicalDeviceIDProperties chain */
6047 
6048 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void * val)6049 vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void *val)
6050 {
6051     /* no known/supported struct */
6052     return vn_sizeof_simple_pointer(NULL);
6053 }
6054 
6055 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties * val)6056 vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties *val)
6057 {
6058     size_t size = 0;
6059     /* skip val->{sType,pNext} */
6060     size += vn_sizeof_array_size(VK_UUID_SIZE);
6061     size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
6062     size += vn_sizeof_array_size(VK_UUID_SIZE);
6063     size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
6064     size += vn_sizeof_array_size(VK_LUID_SIZE);
6065     size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
6066     size += vn_sizeof_uint32_t(&val->deviceNodeMask);
6067     size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
6068     return size;
6069 }
6070 
6071 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * val)6072 vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *val)
6073 {
6074     size_t size = 0;
6075 
6076     size += vn_sizeof_VkStructureType(&val->sType);
6077     size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext(val->pNext);
6078     size += vn_sizeof_VkPhysicalDeviceIDProperties_self(val);
6079 
6080     return size;
6081 }
6082 
6083 static inline void
vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder * dec,const void * val)6084 vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6085 {
6086     /* no known/supported struct */
6087     if (vn_decode_simple_pointer(dec))
6088         assert(false);
6089 }
6090 
6091 static inline void
vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)6092 vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
6093 {
6094     /* skip val->{sType,pNext} */
6095     {
6096         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
6097         vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
6098     }
6099     {
6100         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
6101         vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
6102     }
6103     {
6104         const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
6105         vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
6106     }
6107     vn_decode_uint32_t(dec, &val->deviceNodeMask);
6108     vn_decode_VkBool32(dec, &val->deviceLUIDValid);
6109 }
6110 
6111 static inline void
vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)6112 vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
6113 {
6114     VkStructureType stype;
6115     vn_decode_VkStructureType(dec, &stype);
6116     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
6117 
6118     assert(val->sType == stype);
6119     vn_decode_VkPhysicalDeviceIDProperties_pnext(dec, val->pNext);
6120     vn_decode_VkPhysicalDeviceIDProperties_self(dec, val);
6121 }
6122 
6123 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void * val)6124 vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void *val)
6125 {
6126     /* no known/supported struct */
6127     return vn_sizeof_simple_pointer(NULL);
6128 }
6129 
6130 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties * val)6131 vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties *val)
6132 {
6133     size_t size = 0;
6134     /* skip val->{sType,pNext} */
6135     /* skip val->deviceUUID */
6136     /* skip val->driverUUID */
6137     /* skip val->deviceLUID */
6138     /* skip val->deviceNodeMask */
6139     /* skip val->deviceLUIDValid */
6140     return size;
6141 }
6142 
6143 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties * val)6144 vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties *val)
6145 {
6146     size_t size = 0;
6147 
6148     size += vn_sizeof_VkStructureType(&val->sType);
6149     size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(val->pNext);
6150     size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(val);
6151 
6152     return size;
6153 }
6154 
6155 static inline void
vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6156 vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6157 {
6158     /* no known/supported struct */
6159     vn_encode_simple_pointer(enc, NULL);
6160 }
6161 
6162 static inline void
vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)6163 vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
6164 {
6165     /* skip val->{sType,pNext} */
6166     /* skip val->deviceUUID */
6167     /* skip val->driverUUID */
6168     /* skip val->deviceLUID */
6169     /* skip val->deviceNodeMask */
6170     /* skip val->deviceLUIDValid */
6171 }
6172 
6173 static inline void
vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)6174 vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
6175 {
6176     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
6177     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES });
6178     vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(enc, val->pNext);
6179     vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, val);
6180 }
6181 
6182 /* struct VkPhysicalDeviceMultiviewProperties chain */
6183 
6184 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void * val)6185 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void *val)
6186 {
6187     /* no known/supported struct */
6188     return vn_sizeof_simple_pointer(NULL);
6189 }
6190 
6191 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties * val)6192 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties *val)
6193 {
6194     size_t size = 0;
6195     /* skip val->{sType,pNext} */
6196     size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
6197     size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
6198     return size;
6199 }
6200 
6201 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * val)6202 vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *val)
6203 {
6204     size_t size = 0;
6205 
6206     size += vn_sizeof_VkStructureType(&val->sType);
6207     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(val->pNext);
6208     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(val);
6209 
6210     return size;
6211 }
6212 
6213 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder * dec,const void * val)6214 vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6215 {
6216     /* no known/supported struct */
6217     if (vn_decode_simple_pointer(dec))
6218         assert(false);
6219 }
6220 
6221 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)6222 vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
6223 {
6224     /* skip val->{sType,pNext} */
6225     vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
6226     vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
6227 }
6228 
6229 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)6230 vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
6231 {
6232     VkStructureType stype;
6233     vn_decode_VkStructureType(dec, &stype);
6234     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
6235 
6236     assert(val->sType == stype);
6237     vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(dec, val->pNext);
6238     vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, val);
6239 }
6240 
6241 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void * val)6242 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void *val)
6243 {
6244     /* no known/supported struct */
6245     return vn_sizeof_simple_pointer(NULL);
6246 }
6247 
6248 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties * val)6249 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties *val)
6250 {
6251     size_t size = 0;
6252     /* skip val->{sType,pNext} */
6253     /* skip val->maxMultiviewViewCount */
6254     /* skip val->maxMultiviewInstanceIndex */
6255     return size;
6256 }
6257 
6258 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties * val)6259 vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties *val)
6260 {
6261     size_t size = 0;
6262 
6263     size += vn_sizeof_VkStructureType(&val->sType);
6264     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(val->pNext);
6265     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(val);
6266 
6267     return size;
6268 }
6269 
6270 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6271 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6272 {
6273     /* no known/supported struct */
6274     vn_encode_simple_pointer(enc, NULL);
6275 }
6276 
6277 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)6278 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
6279 {
6280     /* skip val->{sType,pNext} */
6281     /* skip val->maxMultiviewViewCount */
6282     /* skip val->maxMultiviewInstanceIndex */
6283 }
6284 
6285 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)6286 vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
6287 {
6288     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
6289     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES });
6290     vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(enc, val->pNext);
6291     vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, val);
6292 }
6293 
6294 /* struct VkPhysicalDeviceSubgroupProperties chain */
6295 
6296 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void * val)6297 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void *val)
6298 {
6299     /* no known/supported struct */
6300     return vn_sizeof_simple_pointer(NULL);
6301 }
6302 
6303 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties * val)6304 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties *val)
6305 {
6306     size_t size = 0;
6307     /* skip val->{sType,pNext} */
6308     size += vn_sizeof_uint32_t(&val->subgroupSize);
6309     size += vn_sizeof_VkFlags(&val->supportedStages);
6310     size += vn_sizeof_VkFlags(&val->supportedOperations);
6311     size += vn_sizeof_VkBool32(&val->quadOperationsInAllStages);
6312     return size;
6313 }
6314 
6315 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties * val)6316 vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *val)
6317 {
6318     size_t size = 0;
6319 
6320     size += vn_sizeof_VkStructureType(&val->sType);
6321     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(val->pNext);
6322     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(val);
6323 
6324     return size;
6325 }
6326 
6327 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)6328 vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6329 {
6330     /* no known/supported struct */
6331     if (vn_decode_simple_pointer(dec))
6332         assert(false);
6333 }
6334 
6335 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)6336 vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
6337 {
6338     /* skip val->{sType,pNext} */
6339     vn_decode_uint32_t(dec, &val->subgroupSize);
6340     vn_decode_VkFlags(dec, &val->supportedStages);
6341     vn_decode_VkFlags(dec, &val->supportedOperations);
6342     vn_decode_VkBool32(dec, &val->quadOperationsInAllStages);
6343 }
6344 
6345 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)6346 vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
6347 {
6348     VkStructureType stype;
6349     vn_decode_VkStructureType(dec, &stype);
6350     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
6351 
6352     assert(val->sType == stype);
6353     vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(dec, val->pNext);
6354     vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, val);
6355 }
6356 
6357 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void * val)6358 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void *val)
6359 {
6360     /* no known/supported struct */
6361     return vn_sizeof_simple_pointer(NULL);
6362 }
6363 
6364 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties * val)6365 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties *val)
6366 {
6367     size_t size = 0;
6368     /* skip val->{sType,pNext} */
6369     /* skip val->subgroupSize */
6370     /* skip val->supportedStages */
6371     /* skip val->supportedOperations */
6372     /* skip val->quadOperationsInAllStages */
6373     return size;
6374 }
6375 
6376 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties * val)6377 vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties *val)
6378 {
6379     size_t size = 0;
6380 
6381     size += vn_sizeof_VkStructureType(&val->sType);
6382     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(val->pNext);
6383     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(val);
6384 
6385     return size;
6386 }
6387 
6388 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6389 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6390 {
6391     /* no known/supported struct */
6392     vn_encode_simple_pointer(enc, NULL);
6393 }
6394 
6395 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)6396 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
6397 {
6398     /* skip val->{sType,pNext} */
6399     /* skip val->subgroupSize */
6400     /* skip val->supportedStages */
6401     /* skip val->supportedOperations */
6402     /* skip val->quadOperationsInAllStages */
6403 }
6404 
6405 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)6406 vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
6407 {
6408     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
6409     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES });
6410     vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(enc, val->pNext);
6411     vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, val);
6412 }
6413 
6414 /* struct VkPhysicalDevicePointClippingProperties chain */
6415 
6416 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void * val)6417 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void *val)
6418 {
6419     /* no known/supported struct */
6420     return vn_sizeof_simple_pointer(NULL);
6421 }
6422 
6423 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties * val)6424 vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties *val)
6425 {
6426     size_t size = 0;
6427     /* skip val->{sType,pNext} */
6428     size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
6429     return size;
6430 }
6431 
6432 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * val)6433 vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *val)
6434 {
6435     size_t size = 0;
6436 
6437     size += vn_sizeof_VkStructureType(&val->sType);
6438     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(val->pNext);
6439     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self(val);
6440 
6441     return size;
6442 }
6443 
6444 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder * dec,const void * val)6445 vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6446 {
6447     /* no known/supported struct */
6448     if (vn_decode_simple_pointer(dec))
6449         assert(false);
6450 }
6451 
6452 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)6453 vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
6454 {
6455     /* skip val->{sType,pNext} */
6456     vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
6457 }
6458 
6459 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)6460 vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
6461 {
6462     VkStructureType stype;
6463     vn_decode_VkStructureType(dec, &stype);
6464     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
6465 
6466     assert(val->sType == stype);
6467     vn_decode_VkPhysicalDevicePointClippingProperties_pnext(dec, val->pNext);
6468     vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, val);
6469 }
6470 
6471 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void * val)6472 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void *val)
6473 {
6474     /* no known/supported struct */
6475     return vn_sizeof_simple_pointer(NULL);
6476 }
6477 
6478 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties * val)6479 vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties *val)
6480 {
6481     size_t size = 0;
6482     /* skip val->{sType,pNext} */
6483     /* skip val->pointClippingBehavior */
6484     return size;
6485 }
6486 
6487 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties * val)6488 vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties *val)
6489 {
6490     size_t size = 0;
6491 
6492     size += vn_sizeof_VkStructureType(&val->sType);
6493     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(val->pNext);
6494     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(val);
6495 
6496     return size;
6497 }
6498 
6499 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6500 vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6501 {
6502     /* no known/supported struct */
6503     vn_encode_simple_pointer(enc, NULL);
6504 }
6505 
6506 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)6507 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
6508 {
6509     /* skip val->{sType,pNext} */
6510     /* skip val->pointClippingBehavior */
6511 }
6512 
6513 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)6514 vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
6515 {
6516     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
6517     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES });
6518     vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(enc, val->pNext);
6519     vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, val);
6520 }
6521 
6522 /* struct VkPhysicalDeviceProtectedMemoryProperties chain */
6523 
6524 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void * val)6525 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void *val)
6526 {
6527     /* no known/supported struct */
6528     return vn_sizeof_simple_pointer(NULL);
6529 }
6530 
6531 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties * val)6532 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties *val)
6533 {
6534     size_t size = 0;
6535     /* skip val->{sType,pNext} */
6536     size += vn_sizeof_VkBool32(&val->protectedNoFault);
6537     return size;
6538 }
6539 
6540 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * val)6541 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *val)
6542 {
6543     size_t size = 0;
6544 
6545     size += vn_sizeof_VkStructureType(&val->sType);
6546     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(val->pNext);
6547     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(val);
6548 
6549     return size;
6550 }
6551 
6552 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder * dec,const void * val)6553 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6554 {
6555     /* no known/supported struct */
6556     if (vn_decode_simple_pointer(dec))
6557         assert(false);
6558 }
6559 
6560 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)6561 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
6562 {
6563     /* skip val->{sType,pNext} */
6564     vn_decode_VkBool32(dec, &val->protectedNoFault);
6565 }
6566 
6567 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)6568 vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
6569 {
6570     VkStructureType stype;
6571     vn_decode_VkStructureType(dec, &stype);
6572     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
6573 
6574     assert(val->sType == stype);
6575     vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(dec, val->pNext);
6576     vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, val);
6577 }
6578 
6579 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void * val)6580 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void *val)
6581 {
6582     /* no known/supported struct */
6583     return vn_sizeof_simple_pointer(NULL);
6584 }
6585 
6586 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)6587 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
6588 {
6589     size_t size = 0;
6590     /* skip val->{sType,pNext} */
6591     /* skip val->protectedNoFault */
6592     return size;
6593 }
6594 
6595 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)6596 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
6597 {
6598     size_t size = 0;
6599 
6600     size += vn_sizeof_VkStructureType(&val->sType);
6601     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(val->pNext);
6602     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(val);
6603 
6604     return size;
6605 }
6606 
6607 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6608 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6609 {
6610     /* no known/supported struct */
6611     vn_encode_simple_pointer(enc, NULL);
6612 }
6613 
6614 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)6615 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
6616 {
6617     /* skip val->{sType,pNext} */
6618     /* skip val->protectedNoFault */
6619 }
6620 
6621 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)6622 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
6623 {
6624     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
6625     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES });
6626     vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(enc, val->pNext);
6627     vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, val);
6628 }
6629 
6630 /* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */
6631 
6632 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void * val)6633 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void *val)
6634 {
6635     /* no known/supported struct */
6636     return vn_sizeof_simple_pointer(NULL);
6637 }
6638 
6639 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6640 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6641 {
6642     size_t size = 0;
6643     /* skip val->{sType,pNext} */
6644     size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
6645     size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
6646     return size;
6647 }
6648 
6649 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6650 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6651 {
6652     size_t size = 0;
6653 
6654     size += vn_sizeof_VkStructureType(&val->sType);
6655     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(val->pNext);
6656     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(val);
6657 
6658     return size;
6659 }
6660 
6661 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder * dec,const void * val)6662 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6663 {
6664     /* no known/supported struct */
6665     if (vn_decode_simple_pointer(dec))
6666         assert(false);
6667 }
6668 
6669 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6670 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6671 {
6672     /* skip val->{sType,pNext} */
6673     vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
6674     vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
6675 }
6676 
6677 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6678 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6679 {
6680     VkStructureType stype;
6681     vn_decode_VkStructureType(dec, &stype);
6682     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
6683 
6684     assert(val->sType == stype);
6685     vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(dec, val->pNext);
6686     vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, val);
6687 }
6688 
6689 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void * val)6690 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void *val)
6691 {
6692     /* no known/supported struct */
6693     return vn_sizeof_simple_pointer(NULL);
6694 }
6695 
6696 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6697 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6698 {
6699     size_t size = 0;
6700     /* skip val->{sType,pNext} */
6701     /* skip val->filterMinmaxSingleComponentFormats */
6702     /* skip val->filterMinmaxImageComponentMapping */
6703     return size;
6704 }
6705 
6706 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6707 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6708 {
6709     size_t size = 0;
6710 
6711     size += vn_sizeof_VkStructureType(&val->sType);
6712     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(val->pNext);
6713     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(val);
6714 
6715     return size;
6716 }
6717 
6718 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6719 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6720 {
6721     /* no known/supported struct */
6722     vn_encode_simple_pointer(enc, NULL);
6723 }
6724 
6725 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6726 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6727 {
6728     /* skip val->{sType,pNext} */
6729     /* skip val->filterMinmaxSingleComponentFormats */
6730     /* skip val->filterMinmaxImageComponentMapping */
6731 }
6732 
6733 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)6734 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
6735 {
6736     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
6737     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES });
6738     vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(enc, val->pNext);
6739     vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val);
6740 }
6741 
6742 /* struct VkPhysicalDeviceMaintenance3Properties chain */
6743 
6744 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void * val)6745 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void *val)
6746 {
6747     /* no known/supported struct */
6748     return vn_sizeof_simple_pointer(NULL);
6749 }
6750 
6751 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties * val)6752 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties *val)
6753 {
6754     size_t size = 0;
6755     /* skip val->{sType,pNext} */
6756     size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
6757     size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
6758     return size;
6759 }
6760 
6761 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * val)6762 vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *val)
6763 {
6764     size_t size = 0;
6765 
6766     size += vn_sizeof_VkStructureType(&val->sType);
6767     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(val->pNext);
6768     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(val);
6769 
6770     return size;
6771 }
6772 
6773 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder * dec,const void * val)6774 vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder *dec, const void *val)
6775 {
6776     /* no known/supported struct */
6777     if (vn_decode_simple_pointer(dec))
6778         assert(false);
6779 }
6780 
6781 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)6782 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
6783 {
6784     /* skip val->{sType,pNext} */
6785     vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
6786     vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
6787 }
6788 
6789 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)6790 vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
6791 {
6792     VkStructureType stype;
6793     vn_decode_VkStructureType(dec, &stype);
6794     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
6795 
6796     assert(val->sType == stype);
6797     vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(dec, val->pNext);
6798     vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, val);
6799 }
6800 
6801 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void * val)6802 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void *val)
6803 {
6804     /* no known/supported struct */
6805     return vn_sizeof_simple_pointer(NULL);
6806 }
6807 
6808 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties * val)6809 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties *val)
6810 {
6811     size_t size = 0;
6812     /* skip val->{sType,pNext} */
6813     /* skip val->maxPerSetDescriptors */
6814     /* skip val->maxMemoryAllocationSize */
6815     return size;
6816 }
6817 
6818 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties * val)6819 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties *val)
6820 {
6821     size_t size = 0;
6822 
6823     size += vn_sizeof_VkStructureType(&val->sType);
6824     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(val->pNext);
6825     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(val);
6826 
6827     return size;
6828 }
6829 
6830 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6831 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6832 {
6833     /* no known/supported struct */
6834     vn_encode_simple_pointer(enc, NULL);
6835 }
6836 
6837 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)6838 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
6839 {
6840     /* skip val->{sType,pNext} */
6841     /* skip val->maxPerSetDescriptors */
6842     /* skip val->maxMemoryAllocationSize */
6843 }
6844 
6845 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)6846 vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
6847 {
6848     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
6849     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES });
6850     vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(enc, val->pNext);
6851     vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val);
6852 }
6853 
6854 /* struct VkPhysicalDeviceFloatControlsProperties chain */
6855 
6856 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void * val)6857 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void *val)
6858 {
6859     /* no known/supported struct */
6860     return vn_sizeof_simple_pointer(NULL);
6861 }
6862 
6863 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties * val)6864 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties *val)
6865 {
6866     size_t size = 0;
6867     /* skip val->{sType,pNext} */
6868     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
6869     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
6870     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
6871     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
6872     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
6873     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
6874     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
6875     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
6876     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
6877     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
6878     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
6879     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
6880     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
6881     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
6882     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
6883     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
6884     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
6885     return size;
6886 }
6887 
6888 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * val)6889 vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *val)
6890 {
6891     size_t size = 0;
6892 
6893     size += vn_sizeof_VkStructureType(&val->sType);
6894     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(val->pNext);
6895     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(val);
6896 
6897     return size;
6898 }
6899 
6900 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder * dec,const void * val)6901 vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder *dec, const void *val)
6902 {
6903     /* no known/supported struct */
6904     if (vn_decode_simple_pointer(dec))
6905         assert(false);
6906 }
6907 
6908 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)6909 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
6910 {
6911     /* skip val->{sType,pNext} */
6912     vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
6913     vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
6914     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
6915     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
6916     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
6917     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
6918     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
6919     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
6920     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
6921     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
6922     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
6923     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
6924     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
6925     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
6926     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
6927     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
6928     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
6929 }
6930 
6931 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)6932 vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
6933 {
6934     VkStructureType stype;
6935     vn_decode_VkStructureType(dec, &stype);
6936     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
6937 
6938     assert(val->sType == stype);
6939     vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(dec, val->pNext);
6940     vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, val);
6941 }
6942 
6943 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void * val)6944 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void *val)
6945 {
6946     /* no known/supported struct */
6947     return vn_sizeof_simple_pointer(NULL);
6948 }
6949 
6950 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties * val)6951 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties *val)
6952 {
6953     size_t size = 0;
6954     /* skip val->{sType,pNext} */
6955     /* skip val->denormBehaviorIndependence */
6956     /* skip val->roundingModeIndependence */
6957     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
6958     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
6959     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
6960     /* skip val->shaderDenormPreserveFloat16 */
6961     /* skip val->shaderDenormPreserveFloat32 */
6962     /* skip val->shaderDenormPreserveFloat64 */
6963     /* skip val->shaderDenormFlushToZeroFloat16 */
6964     /* skip val->shaderDenormFlushToZeroFloat32 */
6965     /* skip val->shaderDenormFlushToZeroFloat64 */
6966     /* skip val->shaderRoundingModeRTEFloat16 */
6967     /* skip val->shaderRoundingModeRTEFloat32 */
6968     /* skip val->shaderRoundingModeRTEFloat64 */
6969     /* skip val->shaderRoundingModeRTZFloat16 */
6970     /* skip val->shaderRoundingModeRTZFloat32 */
6971     /* skip val->shaderRoundingModeRTZFloat64 */
6972     return size;
6973 }
6974 
6975 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties * val)6976 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties *val)
6977 {
6978     size_t size = 0;
6979 
6980     size += vn_sizeof_VkStructureType(&val->sType);
6981     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(val->pNext);
6982     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(val);
6983 
6984     return size;
6985 }
6986 
6987 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)6988 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6989 {
6990     /* no known/supported struct */
6991     vn_encode_simple_pointer(enc, NULL);
6992 }
6993 
6994 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)6995 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
6996 {
6997     /* skip val->{sType,pNext} */
6998     /* skip val->denormBehaviorIndependence */
6999     /* skip val->roundingModeIndependence */
7000     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
7001     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
7002     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
7003     /* skip val->shaderDenormPreserveFloat16 */
7004     /* skip val->shaderDenormPreserveFloat32 */
7005     /* skip val->shaderDenormPreserveFloat64 */
7006     /* skip val->shaderDenormFlushToZeroFloat16 */
7007     /* skip val->shaderDenormFlushToZeroFloat32 */
7008     /* skip val->shaderDenormFlushToZeroFloat64 */
7009     /* skip val->shaderRoundingModeRTEFloat16 */
7010     /* skip val->shaderRoundingModeRTEFloat32 */
7011     /* skip val->shaderRoundingModeRTEFloat64 */
7012     /* skip val->shaderRoundingModeRTZFloat16 */
7013     /* skip val->shaderRoundingModeRTZFloat32 */
7014     /* skip val->shaderRoundingModeRTZFloat64 */
7015 }
7016 
7017 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)7018 vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
7019 {
7020     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
7021     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES });
7022     vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(enc, val->pNext);
7023     vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, val);
7024 }
7025 
7026 /* struct VkPhysicalDeviceDescriptorIndexingProperties chain */
7027 
7028 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void * val)7029 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void *val)
7030 {
7031     /* no known/supported struct */
7032     return vn_sizeof_simple_pointer(NULL);
7033 }
7034 
7035 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties * val)7036 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7037 {
7038     size_t size = 0;
7039     /* skip val->{sType,pNext} */
7040     size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
7041     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
7042     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
7043     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
7044     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
7045     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
7046     size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
7047     size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
7048     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
7049     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7050     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7051     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7052     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7053     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7054     size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
7055     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
7056     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7057     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7058     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7059     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7060     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
7061     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
7062     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
7063     return size;
7064 }
7065 
7066 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * val)7067 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7068 {
7069     size_t size = 0;
7070 
7071     size += vn_sizeof_VkStructureType(&val->sType);
7072     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(val->pNext);
7073     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(val);
7074 
7075     return size;
7076 }
7077 
7078 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder * dec,const void * val)7079 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
7080 {
7081     /* no known/supported struct */
7082     if (vn_decode_simple_pointer(dec))
7083         assert(false);
7084 }
7085 
7086 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)7087 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
7088 {
7089     /* skip val->{sType,pNext} */
7090     vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
7091     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
7092     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
7093     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
7094     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
7095     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
7096     vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
7097     vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
7098     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
7099     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7100     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7101     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7102     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7103     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7104     vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
7105     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
7106     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7107     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7108     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7109     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7110     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
7111     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
7112     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
7113 }
7114 
7115 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)7116 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
7117 {
7118     VkStructureType stype;
7119     vn_decode_VkStructureType(dec, &stype);
7120     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
7121 
7122     assert(val->sType == stype);
7123     vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(dec, val->pNext);
7124     vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, val);
7125 }
7126 
7127 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void * val)7128 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void *val)
7129 {
7130     /* no known/supported struct */
7131     return vn_sizeof_simple_pointer(NULL);
7132 }
7133 
7134 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)7135 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7136 {
7137     size_t size = 0;
7138     /* skip val->{sType,pNext} */
7139     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
7140     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
7141     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
7142     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
7143     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
7144     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
7145     /* skip val->robustBufferAccessUpdateAfterBind */
7146     /* skip val->quadDivergentImplicitLod */
7147     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
7148     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
7149     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
7150     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
7151     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
7152     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
7153     /* skip val->maxPerStageUpdateAfterBindResources */
7154     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
7155     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
7156     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
7157     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
7158     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
7159     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
7160     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
7161     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
7162     return size;
7163 }
7164 
7165 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)7166 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
7167 {
7168     size_t size = 0;
7169 
7170     size += vn_sizeof_VkStructureType(&val->sType);
7171     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(val->pNext);
7172     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(val);
7173 
7174     return size;
7175 }
7176 
7177 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7178 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7179 {
7180     /* no known/supported struct */
7181     vn_encode_simple_pointer(enc, NULL);
7182 }
7183 
7184 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)7185 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
7186 {
7187     /* skip val->{sType,pNext} */
7188     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
7189     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
7190     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
7191     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
7192     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
7193     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
7194     /* skip val->robustBufferAccessUpdateAfterBind */
7195     /* skip val->quadDivergentImplicitLod */
7196     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
7197     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
7198     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
7199     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
7200     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
7201     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
7202     /* skip val->maxPerStageUpdateAfterBindResources */
7203     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
7204     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
7205     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
7206     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
7207     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
7208     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
7209     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
7210     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
7211 }
7212 
7213 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)7214 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
7215 {
7216     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
7217     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES });
7218     vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(enc, val->pNext);
7219     vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, val);
7220 }
7221 
7222 /* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */
7223 
7224 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void * val)7225 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void *val)
7226 {
7227     /* no known/supported struct */
7228     return vn_sizeof_simple_pointer(NULL);
7229 }
7230 
7231 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7232 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7233 {
7234     size_t size = 0;
7235     /* skip val->{sType,pNext} */
7236     size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
7237     return size;
7238 }
7239 
7240 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7241 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7242 {
7243     size_t size = 0;
7244 
7245     size += vn_sizeof_VkStructureType(&val->sType);
7246     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(val->pNext);
7247     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(val);
7248 
7249     return size;
7250 }
7251 
7252 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)7253 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
7254 {
7255     /* no known/supported struct */
7256     if (vn_decode_simple_pointer(dec))
7257         assert(false);
7258 }
7259 
7260 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)7261 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
7262 {
7263     /* skip val->{sType,pNext} */
7264     vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
7265 }
7266 
7267 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)7268 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
7269 {
7270     VkStructureType stype;
7271     vn_decode_VkStructureType(dec, &stype);
7272     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
7273 
7274     assert(val->sType == stype);
7275     vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(dec, val->pNext);
7276     vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, val);
7277 }
7278 
7279 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void * val)7280 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void *val)
7281 {
7282     /* no known/supported struct */
7283     return vn_sizeof_simple_pointer(NULL);
7284 }
7285 
7286 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7287 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7288 {
7289     size_t size = 0;
7290     /* skip val->{sType,pNext} */
7291     /* skip val->maxTimelineSemaphoreValueDifference */
7292     return size;
7293 }
7294 
7295 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)7296 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7297 {
7298     size_t size = 0;
7299 
7300     size += vn_sizeof_VkStructureType(&val->sType);
7301     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(val->pNext);
7302     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(val);
7303 
7304     return size;
7305 }
7306 
7307 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7308 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7309 {
7310     /* no known/supported struct */
7311     vn_encode_simple_pointer(enc, NULL);
7312 }
7313 
7314 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)7315 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7316 {
7317     /* skip val->{sType,pNext} */
7318     /* skip val->maxTimelineSemaphoreValueDifference */
7319 }
7320 
7321 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)7322 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
7323 {
7324     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
7325     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES });
7326     vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(enc, val->pNext);
7327     vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, val);
7328 }
7329 
7330 /* struct VkPhysicalDeviceDepthStencilResolveProperties chain */
7331 
7332 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void * val)7333 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void *val)
7334 {
7335     /* no known/supported struct */
7336     return vn_sizeof_simple_pointer(NULL);
7337 }
7338 
7339 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties * val)7340 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7341 {
7342     size_t size = 0;
7343     /* skip val->{sType,pNext} */
7344     size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
7345     size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
7346     size += vn_sizeof_VkBool32(&val->independentResolveNone);
7347     size += vn_sizeof_VkBool32(&val->independentResolve);
7348     return size;
7349 }
7350 
7351 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * val)7352 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7353 {
7354     size_t size = 0;
7355 
7356     size += vn_sizeof_VkStructureType(&val->sType);
7357     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(val->pNext);
7358     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(val);
7359 
7360     return size;
7361 }
7362 
7363 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder * dec,const void * val)7364 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder *dec, const void *val)
7365 {
7366     /* no known/supported struct */
7367     if (vn_decode_simple_pointer(dec))
7368         assert(false);
7369 }
7370 
7371 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)7372 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
7373 {
7374     /* skip val->{sType,pNext} */
7375     vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
7376     vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
7377     vn_decode_VkBool32(dec, &val->independentResolveNone);
7378     vn_decode_VkBool32(dec, &val->independentResolve);
7379 }
7380 
7381 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)7382 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
7383 {
7384     VkStructureType stype;
7385     vn_decode_VkStructureType(dec, &stype);
7386     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
7387 
7388     assert(val->sType == stype);
7389     vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(dec, val->pNext);
7390     vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, val);
7391 }
7392 
7393 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void * val)7394 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void *val)
7395 {
7396     /* no known/supported struct */
7397     return vn_sizeof_simple_pointer(NULL);
7398 }
7399 
7400 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)7401 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7402 {
7403     size_t size = 0;
7404     /* skip val->{sType,pNext} */
7405     /* skip val->supportedDepthResolveModes */
7406     /* skip val->supportedStencilResolveModes */
7407     /* skip val->independentResolveNone */
7408     /* skip val->independentResolve */
7409     return size;
7410 }
7411 
7412 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)7413 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
7414 {
7415     size_t size = 0;
7416 
7417     size += vn_sizeof_VkStructureType(&val->sType);
7418     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(val->pNext);
7419     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(val);
7420 
7421     return size;
7422 }
7423 
7424 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7425 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7426 {
7427     /* no known/supported struct */
7428     vn_encode_simple_pointer(enc, NULL);
7429 }
7430 
7431 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)7432 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
7433 {
7434     /* skip val->{sType,pNext} */
7435     /* skip val->supportedDepthResolveModes */
7436     /* skip val->supportedStencilResolveModes */
7437     /* skip val->independentResolveNone */
7438     /* skip val->independentResolve */
7439 }
7440 
7441 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)7442 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
7443 {
7444     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
7445     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES });
7446     vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(enc, val->pNext);
7447     vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, val);
7448 }
7449 
7450 /* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */
7451 
7452 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void * val)7453 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void *val)
7454 {
7455     /* no known/supported struct */
7456     return vn_sizeof_simple_pointer(NULL);
7457 }
7458 
7459 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7460 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7461 {
7462     size_t size = 0;
7463     /* skip val->{sType,pNext} */
7464     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreams);
7465     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBuffers);
7466     size += vn_sizeof_VkDeviceSize(&val->maxTransformFeedbackBufferSize);
7467     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreamDataSize);
7468     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataSize);
7469     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataStride);
7470     size += vn_sizeof_VkBool32(&val->transformFeedbackQueries);
7471     size += vn_sizeof_VkBool32(&val->transformFeedbackStreamsLinesTriangles);
7472     size += vn_sizeof_VkBool32(&val->transformFeedbackRasterizationStreamSelect);
7473     size += vn_sizeof_VkBool32(&val->transformFeedbackDraw);
7474     return size;
7475 }
7476 
7477 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7478 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7479 {
7480     size_t size = 0;
7481 
7482     size += vn_sizeof_VkStructureType(&val->sType);
7483     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(val->pNext);
7484     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(val);
7485 
7486     return size;
7487 }
7488 
7489 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7490 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7491 {
7492     /* no known/supported struct */
7493     if (vn_decode_simple_pointer(dec))
7494         assert(false);
7495 }
7496 
7497 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7498 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7499 {
7500     /* skip val->{sType,pNext} */
7501     vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreams);
7502     vn_decode_uint32_t(dec, &val->maxTransformFeedbackBuffers);
7503     vn_decode_VkDeviceSize(dec, &val->maxTransformFeedbackBufferSize);
7504     vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreamDataSize);
7505     vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataSize);
7506     vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataStride);
7507     vn_decode_VkBool32(dec, &val->transformFeedbackQueries);
7508     vn_decode_VkBool32(dec, &val->transformFeedbackStreamsLinesTriangles);
7509     vn_decode_VkBool32(dec, &val->transformFeedbackRasterizationStreamSelect);
7510     vn_decode_VkBool32(dec, &val->transformFeedbackDraw);
7511 }
7512 
7513 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7514 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7515 {
7516     VkStructureType stype;
7517     vn_decode_VkStructureType(dec, &stype);
7518     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
7519 
7520     assert(val->sType == stype);
7521     vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(dec, val->pNext);
7522     vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, val);
7523 }
7524 
7525 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void * val)7526 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void *val)
7527 {
7528     /* no known/supported struct */
7529     return vn_sizeof_simple_pointer(NULL);
7530 }
7531 
7532 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7533 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7534 {
7535     size_t size = 0;
7536     /* skip val->{sType,pNext} */
7537     /* skip val->maxTransformFeedbackStreams */
7538     /* skip val->maxTransformFeedbackBuffers */
7539     /* skip val->maxTransformFeedbackBufferSize */
7540     /* skip val->maxTransformFeedbackStreamDataSize */
7541     /* skip val->maxTransformFeedbackBufferDataSize */
7542     /* skip val->maxTransformFeedbackBufferDataStride */
7543     /* skip val->transformFeedbackQueries */
7544     /* skip val->transformFeedbackStreamsLinesTriangles */
7545     /* skip val->transformFeedbackRasterizationStreamSelect */
7546     /* skip val->transformFeedbackDraw */
7547     return size;
7548 }
7549 
7550 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7551 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7552 {
7553     size_t size = 0;
7554 
7555     size += vn_sizeof_VkStructureType(&val->sType);
7556     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(val->pNext);
7557     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(val);
7558 
7559     return size;
7560 }
7561 
7562 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7563 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7564 {
7565     /* no known/supported struct */
7566     vn_encode_simple_pointer(enc, NULL);
7567 }
7568 
7569 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7570 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7571 {
7572     /* skip val->{sType,pNext} */
7573     /* skip val->maxTransformFeedbackStreams */
7574     /* skip val->maxTransformFeedbackBuffers */
7575     /* skip val->maxTransformFeedbackBufferSize */
7576     /* skip val->maxTransformFeedbackStreamDataSize */
7577     /* skip val->maxTransformFeedbackBufferDataSize */
7578     /* skip val->maxTransformFeedbackBufferDataStride */
7579     /* skip val->transformFeedbackQueries */
7580     /* skip val->transformFeedbackStreamsLinesTriangles */
7581     /* skip val->transformFeedbackRasterizationStreamSelect */
7582     /* skip val->transformFeedbackDraw */
7583 }
7584 
7585 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)7586 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
7587 {
7588     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
7589     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT });
7590     vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(enc, val->pNext);
7591     vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val);
7592 }
7593 
7594 /* struct VkPhysicalDeviceVulkan11Properties chain */
7595 
7596 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void * val)7597 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void *val)
7598 {
7599     /* no known/supported struct */
7600     return vn_sizeof_simple_pointer(NULL);
7601 }
7602 
7603 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties * val)7604 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties *val)
7605 {
7606     size_t size = 0;
7607     /* skip val->{sType,pNext} */
7608     size += vn_sizeof_array_size(VK_UUID_SIZE);
7609     size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
7610     size += vn_sizeof_array_size(VK_UUID_SIZE);
7611     size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
7612     size += vn_sizeof_array_size(VK_LUID_SIZE);
7613     size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
7614     size += vn_sizeof_uint32_t(&val->deviceNodeMask);
7615     size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
7616     size += vn_sizeof_uint32_t(&val->subgroupSize);
7617     size += vn_sizeof_VkFlags(&val->subgroupSupportedStages);
7618     size += vn_sizeof_VkFlags(&val->subgroupSupportedOperations);
7619     size += vn_sizeof_VkBool32(&val->subgroupQuadOperationsInAllStages);
7620     size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
7621     size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
7622     size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
7623     size += vn_sizeof_VkBool32(&val->protectedNoFault);
7624     size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
7625     size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
7626     return size;
7627 }
7628 
7629 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * val)7630 vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *val)
7631 {
7632     size_t size = 0;
7633 
7634     size += vn_sizeof_VkStructureType(&val->sType);
7635     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(val->pNext);
7636     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(val);
7637 
7638     return size;
7639 }
7640 
7641 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder * dec,const void * val)7642 vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder *dec, const void *val)
7643 {
7644     /* no known/supported struct */
7645     if (vn_decode_simple_pointer(dec))
7646         assert(false);
7647 }
7648 
7649 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)7650 vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
7651 {
7652     /* skip val->{sType,pNext} */
7653     {
7654         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
7655         vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
7656     }
7657     {
7658         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
7659         vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
7660     }
7661     {
7662         const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
7663         vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
7664     }
7665     vn_decode_uint32_t(dec, &val->deviceNodeMask);
7666     vn_decode_VkBool32(dec, &val->deviceLUIDValid);
7667     vn_decode_uint32_t(dec, &val->subgroupSize);
7668     vn_decode_VkFlags(dec, &val->subgroupSupportedStages);
7669     vn_decode_VkFlags(dec, &val->subgroupSupportedOperations);
7670     vn_decode_VkBool32(dec, &val->subgroupQuadOperationsInAllStages);
7671     vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
7672     vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
7673     vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
7674     vn_decode_VkBool32(dec, &val->protectedNoFault);
7675     vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
7676     vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
7677 }
7678 
7679 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)7680 vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
7681 {
7682     VkStructureType stype;
7683     vn_decode_VkStructureType(dec, &stype);
7684     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
7685 
7686     assert(val->sType == stype);
7687     vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(dec, val->pNext);
7688     vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, val);
7689 }
7690 
7691 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void * val)7692 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void *val)
7693 {
7694     /* no known/supported struct */
7695     return vn_sizeof_simple_pointer(NULL);
7696 }
7697 
7698 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties * val)7699 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties *val)
7700 {
7701     size_t size = 0;
7702     /* skip val->{sType,pNext} */
7703     /* skip val->deviceUUID */
7704     /* skip val->driverUUID */
7705     /* skip val->deviceLUID */
7706     /* skip val->deviceNodeMask */
7707     /* skip val->deviceLUIDValid */
7708     /* skip val->subgroupSize */
7709     /* skip val->subgroupSupportedStages */
7710     /* skip val->subgroupSupportedOperations */
7711     /* skip val->subgroupQuadOperationsInAllStages */
7712     /* skip val->pointClippingBehavior */
7713     /* skip val->maxMultiviewViewCount */
7714     /* skip val->maxMultiviewInstanceIndex */
7715     /* skip val->protectedNoFault */
7716     /* skip val->maxPerSetDescriptors */
7717     /* skip val->maxMemoryAllocationSize */
7718     return size;
7719 }
7720 
7721 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties * val)7722 vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties *val)
7723 {
7724     size_t size = 0;
7725 
7726     size += vn_sizeof_VkStructureType(&val->sType);
7727     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(val->pNext);
7728     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(val);
7729 
7730     return size;
7731 }
7732 
7733 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)7734 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7735 {
7736     /* no known/supported struct */
7737     vn_encode_simple_pointer(enc, NULL);
7738 }
7739 
7740 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)7741 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
7742 {
7743     /* skip val->{sType,pNext} */
7744     /* skip val->deviceUUID */
7745     /* skip val->driverUUID */
7746     /* skip val->deviceLUID */
7747     /* skip val->deviceNodeMask */
7748     /* skip val->deviceLUIDValid */
7749     /* skip val->subgroupSize */
7750     /* skip val->subgroupSupportedStages */
7751     /* skip val->subgroupSupportedOperations */
7752     /* skip val->subgroupQuadOperationsInAllStages */
7753     /* skip val->pointClippingBehavior */
7754     /* skip val->maxMultiviewViewCount */
7755     /* skip val->maxMultiviewInstanceIndex */
7756     /* skip val->protectedNoFault */
7757     /* skip val->maxPerSetDescriptors */
7758     /* skip val->maxMemoryAllocationSize */
7759 }
7760 
7761 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)7762 vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
7763 {
7764     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
7765     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES });
7766     vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(enc, val->pNext);
7767     vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, val);
7768 }
7769 
7770 /* struct VkPhysicalDeviceVulkan12Properties chain */
7771 
7772 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void * val)7773 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void *val)
7774 {
7775     /* no known/supported struct */
7776     return vn_sizeof_simple_pointer(NULL);
7777 }
7778 
7779 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties * val)7780 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties *val)
7781 {
7782     size_t size = 0;
7783     /* skip val->{sType,pNext} */
7784     size += vn_sizeof_VkDriverId(&val->driverID);
7785     size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
7786     size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
7787     size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
7788     size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
7789     size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
7790     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
7791     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
7792     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
7793     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
7794     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
7795     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
7796     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
7797     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
7798     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
7799     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
7800     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
7801     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
7802     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
7803     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
7804     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
7805     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
7806     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
7807     size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
7808     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
7809     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
7810     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
7811     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
7812     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
7813     size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
7814     size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
7815     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
7816     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7817     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7818     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7819     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7820     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7821     size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
7822     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
7823     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7824     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7825     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7826     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7827     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
7828     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
7829     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
7830     size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
7831     size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
7832     size += vn_sizeof_VkBool32(&val->independentResolveNone);
7833     size += vn_sizeof_VkBool32(&val->independentResolve);
7834     size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
7835     size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
7836     size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
7837     size += vn_sizeof_VkFlags(&val->framebufferIntegerColorSampleCounts);
7838     return size;
7839 }
7840 
7841 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * val)7842 vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *val)
7843 {
7844     size_t size = 0;
7845 
7846     size += vn_sizeof_VkStructureType(&val->sType);
7847     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(val->pNext);
7848     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(val);
7849 
7850     return size;
7851 }
7852 
7853 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder * dec,const void * val)7854 vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder *dec, const void *val)
7855 {
7856     /* no known/supported struct */
7857     if (vn_decode_simple_pointer(dec))
7858         assert(false);
7859 }
7860 
7861 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)7862 vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
7863 {
7864     /* skip val->{sType,pNext} */
7865     vn_decode_VkDriverId(dec, &val->driverID);
7866     {
7867         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
7868         vn_decode_char_array(dec, val->driverName, array_size);
7869     }
7870     {
7871         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
7872         vn_decode_char_array(dec, val->driverInfo, array_size);
7873     }
7874     vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
7875     vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
7876     vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
7877     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
7878     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
7879     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
7880     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
7881     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
7882     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
7883     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
7884     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
7885     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
7886     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
7887     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
7888     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
7889     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
7890     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
7891     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
7892     vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
7893     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
7894     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
7895     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
7896     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
7897     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
7898     vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
7899     vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
7900     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
7901     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
7902     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
7903     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
7904     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
7905     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
7906     vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
7907     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
7908     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
7909     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
7910     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
7911     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
7912     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
7913     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
7914     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
7915     vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
7916     vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
7917     vn_decode_VkBool32(dec, &val->independentResolveNone);
7918     vn_decode_VkBool32(dec, &val->independentResolve);
7919     vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
7920     vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
7921     vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
7922     vn_decode_VkFlags(dec, &val->framebufferIntegerColorSampleCounts);
7923 }
7924 
7925 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)7926 vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
7927 {
7928     VkStructureType stype;
7929     vn_decode_VkStructureType(dec, &stype);
7930     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
7931 
7932     assert(val->sType == stype);
7933     vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(dec, val->pNext);
7934     vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, val);
7935 }
7936 
7937 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void * val)7938 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void *val)
7939 {
7940     /* no known/supported struct */
7941     return vn_sizeof_simple_pointer(NULL);
7942 }
7943 
7944 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties * val)7945 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties *val)
7946 {
7947     size_t size = 0;
7948     /* skip val->{sType,pNext} */
7949     /* skip val->driverID */
7950     /* skip val->driverName */
7951     /* skip val->driverInfo */
7952     size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
7953     /* skip val->denormBehaviorIndependence */
7954     /* skip val->roundingModeIndependence */
7955     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
7956     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
7957     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
7958     /* skip val->shaderDenormPreserveFloat16 */
7959     /* skip val->shaderDenormPreserveFloat32 */
7960     /* skip val->shaderDenormPreserveFloat64 */
7961     /* skip val->shaderDenormFlushToZeroFloat16 */
7962     /* skip val->shaderDenormFlushToZeroFloat32 */
7963     /* skip val->shaderDenormFlushToZeroFloat64 */
7964     /* skip val->shaderRoundingModeRTEFloat16 */
7965     /* skip val->shaderRoundingModeRTEFloat32 */
7966     /* skip val->shaderRoundingModeRTEFloat64 */
7967     /* skip val->shaderRoundingModeRTZFloat16 */
7968     /* skip val->shaderRoundingModeRTZFloat32 */
7969     /* skip val->shaderRoundingModeRTZFloat64 */
7970     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
7971     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
7972     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
7973     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
7974     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
7975     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
7976     /* skip val->robustBufferAccessUpdateAfterBind */
7977     /* skip val->quadDivergentImplicitLod */
7978     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
7979     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
7980     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
7981     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
7982     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
7983     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
7984     /* skip val->maxPerStageUpdateAfterBindResources */
7985     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
7986     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
7987     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
7988     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
7989     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
7990     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
7991     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
7992     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
7993     /* skip val->supportedDepthResolveModes */
7994     /* skip val->supportedStencilResolveModes */
7995     /* skip val->independentResolveNone */
7996     /* skip val->independentResolve */
7997     /* skip val->filterMinmaxSingleComponentFormats */
7998     /* skip val->filterMinmaxImageComponentMapping */
7999     /* skip val->maxTimelineSemaphoreValueDifference */
8000     /* skip val->framebufferIntegerColorSampleCounts */
8001     return size;
8002 }
8003 
8004 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties * val)8005 vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties *val)
8006 {
8007     size_t size = 0;
8008 
8009     size += vn_sizeof_VkStructureType(&val->sType);
8010     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(val->pNext);
8011     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(val);
8012 
8013     return size;
8014 }
8015 
8016 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)8017 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8018 {
8019     /* no known/supported struct */
8020     vn_encode_simple_pointer(enc, NULL);
8021 }
8022 
8023 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)8024 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
8025 {
8026     /* skip val->{sType,pNext} */
8027     /* skip val->driverID */
8028     /* skip val->driverName */
8029     /* skip val->driverInfo */
8030     vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
8031     /* skip val->denormBehaviorIndependence */
8032     /* skip val->roundingModeIndependence */
8033     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
8034     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
8035     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
8036     /* skip val->shaderDenormPreserveFloat16 */
8037     /* skip val->shaderDenormPreserveFloat32 */
8038     /* skip val->shaderDenormPreserveFloat64 */
8039     /* skip val->shaderDenormFlushToZeroFloat16 */
8040     /* skip val->shaderDenormFlushToZeroFloat32 */
8041     /* skip val->shaderDenormFlushToZeroFloat64 */
8042     /* skip val->shaderRoundingModeRTEFloat16 */
8043     /* skip val->shaderRoundingModeRTEFloat32 */
8044     /* skip val->shaderRoundingModeRTEFloat64 */
8045     /* skip val->shaderRoundingModeRTZFloat16 */
8046     /* skip val->shaderRoundingModeRTZFloat32 */
8047     /* skip val->shaderRoundingModeRTZFloat64 */
8048     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
8049     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
8050     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
8051     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
8052     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
8053     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
8054     /* skip val->robustBufferAccessUpdateAfterBind */
8055     /* skip val->quadDivergentImplicitLod */
8056     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
8057     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
8058     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
8059     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
8060     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
8061     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
8062     /* skip val->maxPerStageUpdateAfterBindResources */
8063     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
8064     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
8065     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
8066     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
8067     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
8068     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
8069     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
8070     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
8071     /* skip val->supportedDepthResolveModes */
8072     /* skip val->supportedStencilResolveModes */
8073     /* skip val->independentResolveNone */
8074     /* skip val->independentResolve */
8075     /* skip val->filterMinmaxSingleComponentFormats */
8076     /* skip val->filterMinmaxImageComponentMapping */
8077     /* skip val->maxTimelineSemaphoreValueDifference */
8078     /* skip val->framebufferIntegerColorSampleCounts */
8079 }
8080 
8081 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)8082 vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
8083 {
8084     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
8085     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES });
8086     vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(enc, val->pNext);
8087     vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val);
8088 }
8089 
8090 /* struct VkPhysicalDeviceProperties2 chain */
8091 
8092 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void * val)8093 vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val)
8094 {
8095     const VkBaseInStructure *pnext = val;
8096     size_t size = 0;
8097 
8098     while (pnext) {
8099         switch ((int32_t)pnext->sType) {
8100         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8101             size += vn_sizeof_simple_pointer(pnext);
8102             size += vn_sizeof_VkStructureType(&pnext->sType);
8103             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8104             size += vn_sizeof_VkPhysicalDeviceDriverProperties_self((const VkPhysicalDeviceDriverProperties *)pnext);
8105             return size;
8106         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8107             size += vn_sizeof_simple_pointer(pnext);
8108             size += vn_sizeof_VkStructureType(&pnext->sType);
8109             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8110             size += vn_sizeof_VkPhysicalDeviceIDProperties_self((const VkPhysicalDeviceIDProperties *)pnext);
8111             return size;
8112         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8113             size += vn_sizeof_simple_pointer(pnext);
8114             size += vn_sizeof_VkStructureType(&pnext->sType);
8115             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8116             size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self((const VkPhysicalDeviceMultiviewProperties *)pnext);
8117             return size;
8118         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8119             size += vn_sizeof_simple_pointer(pnext);
8120             size += vn_sizeof_VkStructureType(&pnext->sType);
8121             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8122             size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self((const VkPhysicalDeviceSubgroupProperties *)pnext);
8123             return size;
8124         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8125             size += vn_sizeof_simple_pointer(pnext);
8126             size += vn_sizeof_VkStructureType(&pnext->sType);
8127             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8128             size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self((const VkPhysicalDevicePointClippingProperties *)pnext);
8129             return size;
8130         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8131             size += vn_sizeof_simple_pointer(pnext);
8132             size += vn_sizeof_VkStructureType(&pnext->sType);
8133             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8134             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8135             return size;
8136         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8137             size += vn_sizeof_simple_pointer(pnext);
8138             size += vn_sizeof_VkStructureType(&pnext->sType);
8139             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8140             size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8141             return size;
8142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8143             size += vn_sizeof_simple_pointer(pnext);
8144             size += vn_sizeof_VkStructureType(&pnext->sType);
8145             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8146             size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext);
8147             return size;
8148         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8149             size += vn_sizeof_simple_pointer(pnext);
8150             size += vn_sizeof_VkStructureType(&pnext->sType);
8151             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8152             size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self((const VkPhysicalDeviceFloatControlsProperties *)pnext);
8153             return size;
8154         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8155             size += vn_sizeof_simple_pointer(pnext);
8156             size += vn_sizeof_VkStructureType(&pnext->sType);
8157             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8158             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8159             return size;
8160         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8161             size += vn_sizeof_simple_pointer(pnext);
8162             size += vn_sizeof_VkStructureType(&pnext->sType);
8163             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8164             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8165             return size;
8166         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8167             size += vn_sizeof_simple_pointer(pnext);
8168             size += vn_sizeof_VkStructureType(&pnext->sType);
8169             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8170             size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8171             return size;
8172         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8173             size += vn_sizeof_simple_pointer(pnext);
8174             size += vn_sizeof_VkStructureType(&pnext->sType);
8175             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8176             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8177             return size;
8178         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8179             size += vn_sizeof_simple_pointer(pnext);
8180             size += vn_sizeof_VkStructureType(&pnext->sType);
8181             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8182             size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self((const VkPhysicalDeviceVulkan11Properties *)pnext);
8183             return size;
8184         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8185             size += vn_sizeof_simple_pointer(pnext);
8186             size += vn_sizeof_VkStructureType(&pnext->sType);
8187             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
8188             size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext);
8189             return size;
8190         default:
8191             /* ignore unknown/unsupported struct */
8192             break;
8193         }
8194         pnext = pnext->pNext;
8195     }
8196 
8197     return vn_sizeof_simple_pointer(NULL);
8198 }
8199 
8200 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 * val)8201 vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 *val)
8202 {
8203     size_t size = 0;
8204     /* skip val->{sType,pNext} */
8205     size += vn_sizeof_VkPhysicalDeviceProperties(&val->properties);
8206     return size;
8207 }
8208 
8209 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * val)8210 vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *val)
8211 {
8212     size_t size = 0;
8213 
8214     size += vn_sizeof_VkStructureType(&val->sType);
8215     size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(val->pNext);
8216     size += vn_sizeof_VkPhysicalDeviceProperties2_self(val);
8217 
8218     return size;
8219 }
8220 
8221 static inline void
vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder * dec,const void * val)8222 vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
8223 {
8224     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
8225     VkStructureType stype;
8226 
8227     if (!vn_decode_simple_pointer(dec))
8228         return;
8229 
8230     vn_decode_VkStructureType(dec, &stype);
8231     while (true) {
8232         assert(pnext);
8233         if (pnext->sType == stype)
8234             break;
8235     }
8236 
8237     switch ((int32_t)pnext->sType) {
8238     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8239         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8240         vn_decode_VkPhysicalDeviceDriverProperties_self(dec, (VkPhysicalDeviceDriverProperties *)pnext);
8241         break;
8242     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8243         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8244         vn_decode_VkPhysicalDeviceIDProperties_self(dec, (VkPhysicalDeviceIDProperties *)pnext);
8245         break;
8246     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8247         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8248         vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, (VkPhysicalDeviceMultiviewProperties *)pnext);
8249         break;
8250     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8251         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8252         vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, (VkPhysicalDeviceSubgroupProperties *)pnext);
8253         break;
8254     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8255         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8256         vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, (VkPhysicalDevicePointClippingProperties *)pnext);
8257         break;
8258     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8259         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8260         vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8261         break;
8262     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8263         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8264         vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8265         break;
8266     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8267         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8268         vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext);
8269         break;
8270     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8271         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8272         vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
8273         break;
8274     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8275         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8276         vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8277         break;
8278     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8279         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8280         vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8281         break;
8282     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8283         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8284         vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8285         break;
8286     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8287         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8288         vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8289         break;
8290     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8291         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8292         vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext);
8293         break;
8294     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8295         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
8296         vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext);
8297         break;
8298     default:
8299         assert(false);
8300         break;
8301     }
8302 }
8303 
8304 static inline void
vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)8305 vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
8306 {
8307     /* skip val->{sType,pNext} */
8308     vn_decode_VkPhysicalDeviceProperties(dec, &val->properties);
8309 }
8310 
8311 static inline void
vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)8312 vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
8313 {
8314     VkStructureType stype;
8315     vn_decode_VkStructureType(dec, &stype);
8316     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
8317 
8318     assert(val->sType == stype);
8319     vn_decode_VkPhysicalDeviceProperties2_pnext(dec, val->pNext);
8320     vn_decode_VkPhysicalDeviceProperties2_self(dec, val);
8321 }
8322 
8323 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void * val)8324 vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val)
8325 {
8326     const VkBaseInStructure *pnext = val;
8327     size_t size = 0;
8328 
8329     while (pnext) {
8330         switch ((int32_t)pnext->sType) {
8331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8332             size += vn_sizeof_simple_pointer(pnext);
8333             size += vn_sizeof_VkStructureType(&pnext->sType);
8334             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8335             size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial((const VkPhysicalDeviceDriverProperties *)pnext);
8336             return size;
8337         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8338             size += vn_sizeof_simple_pointer(pnext);
8339             size += vn_sizeof_VkStructureType(&pnext->sType);
8340             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8341             size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial((const VkPhysicalDeviceIDProperties *)pnext);
8342             return size;
8343         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8344             size += vn_sizeof_simple_pointer(pnext);
8345             size += vn_sizeof_VkStructureType(&pnext->sType);
8346             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8347             size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial((const VkPhysicalDeviceMultiviewProperties *)pnext);
8348             return size;
8349         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8350             size += vn_sizeof_simple_pointer(pnext);
8351             size += vn_sizeof_VkStructureType(&pnext->sType);
8352             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8353             size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial((const VkPhysicalDeviceSubgroupProperties *)pnext);
8354             return size;
8355         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8356             size += vn_sizeof_simple_pointer(pnext);
8357             size += vn_sizeof_VkStructureType(&pnext->sType);
8358             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8359             size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial((const VkPhysicalDevicePointClippingProperties *)pnext);
8360             return size;
8361         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8362             size += vn_sizeof_simple_pointer(pnext);
8363             size += vn_sizeof_VkStructureType(&pnext->sType);
8364             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8365             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8366             return size;
8367         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8368             size += vn_sizeof_simple_pointer(pnext);
8369             size += vn_sizeof_VkStructureType(&pnext->sType);
8370             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8371             size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8372             return size;
8373         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8374             size += vn_sizeof_simple_pointer(pnext);
8375             size += vn_sizeof_VkStructureType(&pnext->sType);
8376             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8377             size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext);
8378             return size;
8379         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8380             size += vn_sizeof_simple_pointer(pnext);
8381             size += vn_sizeof_VkStructureType(&pnext->sType);
8382             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8383             size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial((const VkPhysicalDeviceFloatControlsProperties *)pnext);
8384             return size;
8385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8386             size += vn_sizeof_simple_pointer(pnext);
8387             size += vn_sizeof_VkStructureType(&pnext->sType);
8388             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8389             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8390             return size;
8391         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8392             size += vn_sizeof_simple_pointer(pnext);
8393             size += vn_sizeof_VkStructureType(&pnext->sType);
8394             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8395             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8396             return size;
8397         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8398             size += vn_sizeof_simple_pointer(pnext);
8399             size += vn_sizeof_VkStructureType(&pnext->sType);
8400             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8401             size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8402             return size;
8403         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8404             size += vn_sizeof_simple_pointer(pnext);
8405             size += vn_sizeof_VkStructureType(&pnext->sType);
8406             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8407             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8408             return size;
8409         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8410             size += vn_sizeof_simple_pointer(pnext);
8411             size += vn_sizeof_VkStructureType(&pnext->sType);
8412             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8413             size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial((const VkPhysicalDeviceVulkan11Properties *)pnext);
8414             return size;
8415         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8416             size += vn_sizeof_simple_pointer(pnext);
8417             size += vn_sizeof_VkStructureType(&pnext->sType);
8418             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
8419             size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext);
8420             return size;
8421         default:
8422             /* ignore unknown/unsupported struct */
8423             break;
8424         }
8425         pnext = pnext->pNext;
8426     }
8427 
8428     return vn_sizeof_simple_pointer(NULL);
8429 }
8430 
8431 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 * val)8432 vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 *val)
8433 {
8434     size_t size = 0;
8435     /* skip val->{sType,pNext} */
8436     size += vn_sizeof_VkPhysicalDeviceProperties_partial(&val->properties);
8437     return size;
8438 }
8439 
8440 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 * val)8441 vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 *val)
8442 {
8443     size_t size = 0;
8444 
8445     size += vn_sizeof_VkStructureType(&val->sType);
8446     size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(val->pNext);
8447     size += vn_sizeof_VkPhysicalDeviceProperties2_self_partial(val);
8448 
8449     return size;
8450 }
8451 
8452 static inline void
vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)8453 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8454 {
8455     const VkBaseInStructure *pnext = val;
8456 
8457     while (pnext) {
8458         switch ((int32_t)pnext->sType) {
8459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
8460             vn_encode_simple_pointer(enc, pnext);
8461             vn_encode_VkStructureType(enc, &pnext->sType);
8462             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8463             vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, (const VkPhysicalDeviceDriverProperties *)pnext);
8464             return;
8465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
8466             vn_encode_simple_pointer(enc, pnext);
8467             vn_encode_VkStructureType(enc, &pnext->sType);
8468             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8469             vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, (const VkPhysicalDeviceIDProperties *)pnext);
8470             return;
8471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
8472             vn_encode_simple_pointer(enc, pnext);
8473             vn_encode_VkStructureType(enc, &pnext->sType);
8474             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8475             vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext);
8476             return;
8477         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
8478             vn_encode_simple_pointer(enc, pnext);
8479             vn_encode_VkStructureType(enc, &pnext->sType);
8480             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8481             vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext);
8482             return;
8483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
8484             vn_encode_simple_pointer(enc, pnext);
8485             vn_encode_VkStructureType(enc, &pnext->sType);
8486             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8487             vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, (const VkPhysicalDevicePointClippingProperties *)pnext);
8488             return;
8489         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
8490             vn_encode_simple_pointer(enc, pnext);
8491             vn_encode_VkStructureType(enc, &pnext->sType);
8492             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8493             vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
8494             return;
8495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
8496             vn_encode_simple_pointer(enc, pnext);
8497             vn_encode_VkStructureType(enc, &pnext->sType);
8498             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8499             vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
8500             return;
8501         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
8502             vn_encode_simple_pointer(enc, pnext);
8503             vn_encode_VkStructureType(enc, &pnext->sType);
8504             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8505             vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext);
8506             return;
8507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
8508             vn_encode_simple_pointer(enc, pnext);
8509             vn_encode_VkStructureType(enc, &pnext->sType);
8510             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8511             vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext);
8512             return;
8513         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
8514             vn_encode_simple_pointer(enc, pnext);
8515             vn_encode_VkStructureType(enc, &pnext->sType);
8516             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8517             vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
8518             return;
8519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
8520             vn_encode_simple_pointer(enc, pnext);
8521             vn_encode_VkStructureType(enc, &pnext->sType);
8522             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8523             vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
8524             return;
8525         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
8526             vn_encode_simple_pointer(enc, pnext);
8527             vn_encode_VkStructureType(enc, &pnext->sType);
8528             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8529             vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
8530             return;
8531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
8532             vn_encode_simple_pointer(enc, pnext);
8533             vn_encode_VkStructureType(enc, &pnext->sType);
8534             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8535             vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
8536             return;
8537         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
8538             vn_encode_simple_pointer(enc, pnext);
8539             vn_encode_VkStructureType(enc, &pnext->sType);
8540             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8541             vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext);
8542             return;
8543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
8544             vn_encode_simple_pointer(enc, pnext);
8545             vn_encode_VkStructureType(enc, &pnext->sType);
8546             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
8547             vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext);
8548             return;
8549         default:
8550             /* ignore unknown/unsupported struct */
8551             break;
8552         }
8553         pnext = pnext->pNext;
8554     }
8555 
8556     vn_encode_simple_pointer(enc, NULL);
8557 }
8558 
8559 static inline void
vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)8560 vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
8561 {
8562     /* skip val->{sType,pNext} */
8563     vn_encode_VkPhysicalDeviceProperties_partial(enc, &val->properties);
8564 }
8565 
8566 static inline void
vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)8567 vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
8568 {
8569     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
8570     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 });
8571     vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, val->pNext);
8572     vn_encode_VkPhysicalDeviceProperties2_self_partial(enc, val);
8573 }
8574 
8575 /* struct VkDrmFormatModifierPropertiesEXT */
8576 
8577 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * val)8578 vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *val)
8579 {
8580     size_t size = 0;
8581     size += vn_sizeof_uint64_t(&val->drmFormatModifier);
8582     size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
8583     size += vn_sizeof_VkFlags(&val->drmFormatModifierTilingFeatures);
8584     return size;
8585 }
8586 
8587 static inline void
vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesEXT * val)8588 vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val)
8589 {
8590     vn_decode_uint64_t(dec, &val->drmFormatModifier);
8591     vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
8592     vn_decode_VkFlags(dec, &val->drmFormatModifierTilingFeatures);
8593 }
8594 
8595 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT * val)8596 vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT *val)
8597 {
8598     size_t size = 0;
8599     /* skip val->drmFormatModifier */
8600     /* skip val->drmFormatModifierPlaneCount */
8601     /* skip val->drmFormatModifierTilingFeatures */
8602     return size;
8603 }
8604 
8605 static inline void
vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesEXT * val)8606 vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val)
8607 {
8608     /* skip val->drmFormatModifier */
8609     /* skip val->drmFormatModifierPlaneCount */
8610     /* skip val->drmFormatModifierTilingFeatures */
8611 }
8612 
8613 /* struct VkDrmFormatModifierPropertiesListEXT chain */
8614 
8615 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void * val)8616 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void *val)
8617 {
8618     /* no known/supported struct */
8619     return vn_sizeof_simple_pointer(NULL);
8620 }
8621 
8622 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT * val)8623 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT *val)
8624 {
8625     size_t size = 0;
8626     /* skip val->{sType,pNext} */
8627     size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
8628     if (val->pDrmFormatModifierProperties) {
8629         size += vn_sizeof_array_size(val->drmFormatModifierCount);
8630         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
8631             size += vn_sizeof_VkDrmFormatModifierPropertiesEXT(&val->pDrmFormatModifierProperties[i]);
8632     } else {
8633         size += vn_sizeof_array_size(0);
8634     }
8635     return size;
8636 }
8637 
8638 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * val)8639 vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *val)
8640 {
8641     size_t size = 0;
8642 
8643     size += vn_sizeof_VkStructureType(&val->sType);
8644     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(val->pNext);
8645     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(val);
8646 
8647     return size;
8648 }
8649 
8650 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder * dec,const void * val)8651 vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder *dec, const void *val)
8652 {
8653     /* no known/supported struct */
8654     if (vn_decode_simple_pointer(dec))
8655         assert(false);
8656 }
8657 
8658 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)8659 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
8660 {
8661     /* skip val->{sType,pNext} */
8662     vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
8663     if (vn_peek_array_size(dec)) {
8664         const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount);
8665         for (uint32_t i = 0; i < iter_count; i++)
8666             vn_decode_VkDrmFormatModifierPropertiesEXT(dec, &val->pDrmFormatModifierProperties[i]);
8667     } else {
8668         vn_decode_array_size_unchecked(dec);
8669         val->pDrmFormatModifierProperties = NULL;
8670     }
8671 }
8672 
8673 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)8674 vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
8675 {
8676     VkStructureType stype;
8677     vn_decode_VkStructureType(dec, &stype);
8678     assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
8679 
8680     assert(val->sType == stype);
8681     vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(dec, val->pNext);
8682     vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, val);
8683 }
8684 
8685 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void * val)8686 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void *val)
8687 {
8688     /* no known/supported struct */
8689     return vn_sizeof_simple_pointer(NULL);
8690 }
8691 
8692 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT * val)8693 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT *val)
8694 {
8695     size_t size = 0;
8696     /* skip val->{sType,pNext} */
8697     /* WA1: size += vn_sizeof_uint32_t(&val->drmFormatModifierCount) */(void)0;
8698     if (val->pDrmFormatModifierProperties) {
8699         size += vn_sizeof_array_size(val->drmFormatModifierCount);
8700         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
8701             size += vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(&val->pDrmFormatModifierProperties[i]);
8702     } else {
8703         size += vn_sizeof_array_size(0);
8704     }
8705     return size;
8706 }
8707 
8708 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT * val)8709 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT *val)
8710 {
8711     size_t size = 0;
8712 
8713     size += vn_sizeof_VkStructureType(&val->sType);
8714     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(val->pNext);
8715     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(val);
8716 
8717     return size;
8718 }
8719 
8720 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)8721 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8722 {
8723     /* no known/supported struct */
8724     vn_encode_simple_pointer(enc, NULL);
8725 }
8726 
8727 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)8728 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
8729 {
8730     /* skip val->{sType,pNext} */
8731     /* WA1: vn_encode_uint32_t(enc, &val->drmFormatModifierCount) */(void)0;
8732     if (val->pDrmFormatModifierProperties) {
8733         vn_encode_array_size(enc, val->drmFormatModifierCount);
8734         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
8735             vn_encode_VkDrmFormatModifierPropertiesEXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
8736     } else {
8737         vn_encode_array_size(enc, 0);
8738     }
8739 }
8740 
8741 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)8742 vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
8743 {
8744     assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
8745     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT });
8746     vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(enc, val->pNext);
8747     vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val);
8748 }
8749 
8750 /* struct VkFormatProperties2 chain */
8751 
8752 static inline size_t
vn_sizeof_VkFormatProperties2_pnext(const void * val)8753 vn_sizeof_VkFormatProperties2_pnext(const void *val)
8754 {
8755     const VkBaseInStructure *pnext = val;
8756     size_t size = 0;
8757 
8758     while (pnext) {
8759         switch ((int32_t)pnext->sType) {
8760         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8761             size += vn_sizeof_simple_pointer(pnext);
8762             size += vn_sizeof_VkStructureType(&pnext->sType);
8763             size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
8764             size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext);
8765             return size;
8766         default:
8767             /* ignore unknown/unsupported struct */
8768             break;
8769         }
8770         pnext = pnext->pNext;
8771     }
8772 
8773     return vn_sizeof_simple_pointer(NULL);
8774 }
8775 
8776 static inline size_t
vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 * val)8777 vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 *val)
8778 {
8779     size_t size = 0;
8780     /* skip val->{sType,pNext} */
8781     size += vn_sizeof_VkFormatProperties(&val->formatProperties);
8782     return size;
8783 }
8784 
8785 static inline size_t
vn_sizeof_VkFormatProperties2(const VkFormatProperties2 * val)8786 vn_sizeof_VkFormatProperties2(const VkFormatProperties2 *val)
8787 {
8788     size_t size = 0;
8789 
8790     size += vn_sizeof_VkStructureType(&val->sType);
8791     size += vn_sizeof_VkFormatProperties2_pnext(val->pNext);
8792     size += vn_sizeof_VkFormatProperties2_self(val);
8793 
8794     return size;
8795 }
8796 
8797 static inline void
vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)8798 vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
8799 {
8800     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
8801     VkStructureType stype;
8802 
8803     if (!vn_decode_simple_pointer(dec))
8804         return;
8805 
8806     vn_decode_VkStructureType(dec, &stype);
8807     while (true) {
8808         assert(pnext);
8809         if (pnext->sType == stype)
8810             break;
8811     }
8812 
8813     switch ((int32_t)pnext->sType) {
8814     case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8815         vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
8816         vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext);
8817         break;
8818     default:
8819         assert(false);
8820         break;
8821     }
8822 }
8823 
8824 static inline void
vn_decode_VkFormatProperties2_self(struct vn_cs_decoder * dec,VkFormatProperties2 * val)8825 vn_decode_VkFormatProperties2_self(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
8826 {
8827     /* skip val->{sType,pNext} */
8828     vn_decode_VkFormatProperties(dec, &val->formatProperties);
8829 }
8830 
8831 static inline void
vn_decode_VkFormatProperties2(struct vn_cs_decoder * dec,VkFormatProperties2 * val)8832 vn_decode_VkFormatProperties2(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
8833 {
8834     VkStructureType stype;
8835     vn_decode_VkStructureType(dec, &stype);
8836     assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
8837 
8838     assert(val->sType == stype);
8839     vn_decode_VkFormatProperties2_pnext(dec, val->pNext);
8840     vn_decode_VkFormatProperties2_self(dec, val);
8841 }
8842 
8843 static inline size_t
vn_sizeof_VkFormatProperties2_pnext_partial(const void * val)8844 vn_sizeof_VkFormatProperties2_pnext_partial(const void *val)
8845 {
8846     const VkBaseInStructure *pnext = val;
8847     size_t size = 0;
8848 
8849     while (pnext) {
8850         switch ((int32_t)pnext->sType) {
8851         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8852             size += vn_sizeof_simple_pointer(pnext);
8853             size += vn_sizeof_VkStructureType(&pnext->sType);
8854             size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
8855             size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext);
8856             return size;
8857         default:
8858             /* ignore unknown/unsupported struct */
8859             break;
8860         }
8861         pnext = pnext->pNext;
8862     }
8863 
8864     return vn_sizeof_simple_pointer(NULL);
8865 }
8866 
8867 static inline size_t
vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 * val)8868 vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 *val)
8869 {
8870     size_t size = 0;
8871     /* skip val->{sType,pNext} */
8872     size += vn_sizeof_VkFormatProperties_partial(&val->formatProperties);
8873     return size;
8874 }
8875 
8876 static inline size_t
vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 * val)8877 vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 *val)
8878 {
8879     size_t size = 0;
8880 
8881     size += vn_sizeof_VkStructureType(&val->sType);
8882     size += vn_sizeof_VkFormatProperties2_pnext_partial(val->pNext);
8883     size += vn_sizeof_VkFormatProperties2_self_partial(val);
8884 
8885     return size;
8886 }
8887 
8888 static inline void
vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)8889 vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8890 {
8891     const VkBaseInStructure *pnext = val;
8892 
8893     while (pnext) {
8894         switch ((int32_t)pnext->sType) {
8895         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
8896             vn_encode_simple_pointer(enc, pnext);
8897             vn_encode_VkStructureType(enc, &pnext->sType);
8898             vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
8899             vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext);
8900             return;
8901         default:
8902             /* ignore unknown/unsupported struct */
8903             break;
8904         }
8905         pnext = pnext->pNext;
8906     }
8907 
8908     vn_encode_simple_pointer(enc, NULL);
8909 }
8910 
8911 static inline void
vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)8912 vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
8913 {
8914     /* skip val->{sType,pNext} */
8915     vn_encode_VkFormatProperties_partial(enc, &val->formatProperties);
8916 }
8917 
8918 static inline void
vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)8919 vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
8920 {
8921     assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
8922     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 });
8923     vn_encode_VkFormatProperties2_pnext_partial(enc, val->pNext);
8924     vn_encode_VkFormatProperties2_self_partial(enc, val);
8925 }
8926 
8927 /* struct VkPhysicalDeviceExternalImageFormatInfo chain */
8928 
8929 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void * val)8930 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void *val)
8931 {
8932     /* no known/supported struct */
8933     return vn_sizeof_simple_pointer(NULL);
8934 }
8935 
8936 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo * val)8937 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo *val)
8938 {
8939     size_t size = 0;
8940     /* skip val->{sType,pNext} */
8941     size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
8942     return size;
8943 }
8944 
8945 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * val)8946 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *val)
8947 {
8948     size_t size = 0;
8949 
8950     size += vn_sizeof_VkStructureType(&val->sType);
8951     size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(val->pNext);
8952     size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(val);
8953 
8954     return size;
8955 }
8956 
8957 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder * enc,const void * val)8958 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder *enc, const void *val)
8959 {
8960     /* no known/supported struct */
8961     vn_encode_simple_pointer(enc, NULL);
8962 }
8963 
8964 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)8965 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
8966 {
8967     /* skip val->{sType,pNext} */
8968     vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
8969 }
8970 
8971 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)8972 vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
8973 {
8974     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
8975     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO });
8976     vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(enc, val->pNext);
8977     vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, val);
8978 }
8979 
8980 /* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */
8981 
8982 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void * val)8983 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void *val)
8984 {
8985     /* no known/supported struct */
8986     return vn_sizeof_simple_pointer(NULL);
8987 }
8988 
8989 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)8990 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
8991 {
8992     size_t size = 0;
8993     /* skip val->{sType,pNext} */
8994     size += vn_sizeof_uint64_t(&val->drmFormatModifier);
8995     size += vn_sizeof_VkSharingMode(&val->sharingMode);
8996     size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
8997     if (val->pQueueFamilyIndices) {
8998         size += vn_sizeof_array_size(val->queueFamilyIndexCount);
8999         size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
9000     } else {
9001         size += vn_sizeof_array_size(0);
9002     }
9003     return size;
9004 }
9005 
9006 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)9007 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
9008 {
9009     size_t size = 0;
9010 
9011     size += vn_sizeof_VkStructureType(&val->sType);
9012     size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(val->pNext);
9013     size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(val);
9014 
9015     return size;
9016 }
9017 
9018 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)9019 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
9020 {
9021     /* no known/supported struct */
9022     vn_encode_simple_pointer(enc, NULL);
9023 }
9024 
9025 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)9026 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
9027 {
9028     /* skip val->{sType,pNext} */
9029     vn_encode_uint64_t(enc, &val->drmFormatModifier);
9030     vn_encode_VkSharingMode(enc, &val->sharingMode);
9031     vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
9032     if (val->pQueueFamilyIndices) {
9033         vn_encode_array_size(enc, val->queueFamilyIndexCount);
9034         vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
9035     } else {
9036         vn_encode_array_size(enc, 0);
9037     }
9038 }
9039 
9040 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)9041 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
9042 {
9043     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
9044     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT });
9045     vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(enc, val->pNext);
9046     vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, val);
9047 }
9048 
9049 /* struct VkPhysicalDeviceImageFormatInfo2 chain */
9050 
9051 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void * val)9052 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void *val)
9053 {
9054     const VkBaseInStructure *pnext = val;
9055     size_t size = 0;
9056 
9057     while (pnext) {
9058         switch ((int32_t)pnext->sType) {
9059         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
9060             size += vn_sizeof_simple_pointer(pnext);
9061             size += vn_sizeof_VkStructureType(&pnext->sType);
9062             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9063             size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self((const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
9064             return size;
9065         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
9066             size += vn_sizeof_simple_pointer(pnext);
9067             size += vn_sizeof_VkStructureType(&pnext->sType);
9068             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9069             size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
9070             return size;
9071         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
9072             size += vn_sizeof_simple_pointer(pnext);
9073             size += vn_sizeof_VkStructureType(&pnext->sType);
9074             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9075             size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self((const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
9076             return size;
9077         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
9078             size += vn_sizeof_simple_pointer(pnext);
9079             size += vn_sizeof_VkStructureType(&pnext->sType);
9080             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
9081             size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
9082             return size;
9083         default:
9084             /* ignore unknown/unsupported struct */
9085             break;
9086         }
9087         pnext = pnext->pNext;
9088     }
9089 
9090     return vn_sizeof_simple_pointer(NULL);
9091 }
9092 
9093 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 * val)9094 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 *val)
9095 {
9096     size_t size = 0;
9097     /* skip val->{sType,pNext} */
9098     size += vn_sizeof_VkFormat(&val->format);
9099     size += vn_sizeof_VkImageType(&val->type);
9100     size += vn_sizeof_VkImageTiling(&val->tiling);
9101     size += vn_sizeof_VkFlags(&val->usage);
9102     size += vn_sizeof_VkFlags(&val->flags);
9103     return size;
9104 }
9105 
9106 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * val)9107 vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *val)
9108 {
9109     size_t size = 0;
9110 
9111     size += vn_sizeof_VkStructureType(&val->sType);
9112     size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(val->pNext);
9113     size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(val);
9114 
9115     return size;
9116 }
9117 
9118 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)9119 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
9120 {
9121     const VkBaseInStructure *pnext = val;
9122 
9123     while (pnext) {
9124         switch ((int32_t)pnext->sType) {
9125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
9126             vn_encode_simple_pointer(enc, pnext);
9127             vn_encode_VkStructureType(enc, &pnext->sType);
9128             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9129             vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, (const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
9130             return;
9131         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
9132             vn_encode_simple_pointer(enc, pnext);
9133             vn_encode_VkStructureType(enc, &pnext->sType);
9134             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9135             vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
9136             return;
9137         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
9138             vn_encode_simple_pointer(enc, pnext);
9139             vn_encode_VkStructureType(enc, &pnext->sType);
9140             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9141             vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
9142             return;
9143         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
9144             vn_encode_simple_pointer(enc, pnext);
9145             vn_encode_VkStructureType(enc, &pnext->sType);
9146             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
9147             vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
9148             return;
9149         default:
9150             /* ignore unknown/unsupported struct */
9151             break;
9152         }
9153         pnext = pnext->pNext;
9154     }
9155 
9156     vn_encode_simple_pointer(enc, NULL);
9157 }
9158 
9159 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)9160 vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
9161 {
9162     /* skip val->{sType,pNext} */
9163     vn_encode_VkFormat(enc, &val->format);
9164     vn_encode_VkImageType(enc, &val->type);
9165     vn_encode_VkImageTiling(enc, &val->tiling);
9166     vn_encode_VkFlags(enc, &val->usage);
9167     vn_encode_VkFlags(enc, &val->flags);
9168 }
9169 
9170 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)9171 vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
9172 {
9173     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
9174     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 });
9175     vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, val->pNext);
9176     vn_encode_VkPhysicalDeviceImageFormatInfo2_self(enc, val);
9177 }
9178 
9179 /* struct VkExternalMemoryProperties */
9180 
9181 static inline size_t
vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties * val)9182 vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties *val)
9183 {
9184     size_t size = 0;
9185     size += vn_sizeof_VkFlags(&val->externalMemoryFeatures);
9186     size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
9187     size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
9188     return size;
9189 }
9190 
9191 static inline void
vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder * dec,VkExternalMemoryProperties * val)9192 vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val)
9193 {
9194     vn_decode_VkFlags(dec, &val->externalMemoryFeatures);
9195     vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
9196     vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
9197 }
9198 
9199 static inline size_t
vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties * val)9200 vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties *val)
9201 {
9202     size_t size = 0;
9203     /* skip val->externalMemoryFeatures */
9204     /* skip val->exportFromImportedHandleTypes */
9205     /* skip val->compatibleHandleTypes */
9206     return size;
9207 }
9208 
9209 static inline void
vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder * enc,const VkExternalMemoryProperties * val)9210 vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val)
9211 {
9212     /* skip val->externalMemoryFeatures */
9213     /* skip val->exportFromImportedHandleTypes */
9214     /* skip val->compatibleHandleTypes */
9215 }
9216 
9217 /* struct VkExternalImageFormatProperties chain */
9218 
9219 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext(const void * val)9220 vn_sizeof_VkExternalImageFormatProperties_pnext(const void *val)
9221 {
9222     /* no known/supported struct */
9223     return vn_sizeof_simple_pointer(NULL);
9224 }
9225 
9226 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties * val)9227 vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties *val)
9228 {
9229     size_t size = 0;
9230     /* skip val->{sType,pNext} */
9231     size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
9232     return size;
9233 }
9234 
9235 static inline size_t
vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * val)9236 vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *val)
9237 {
9238     size_t size = 0;
9239 
9240     size += vn_sizeof_VkStructureType(&val->sType);
9241     size += vn_sizeof_VkExternalImageFormatProperties_pnext(val->pNext);
9242     size += vn_sizeof_VkExternalImageFormatProperties_self(val);
9243 
9244     return size;
9245 }
9246 
9247 static inline void
vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)9248 vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
9249 {
9250     /* no known/supported struct */
9251     if (vn_decode_simple_pointer(dec))
9252         assert(false);
9253 }
9254 
9255 static inline void
vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)9256 vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
9257 {
9258     /* skip val->{sType,pNext} */
9259     vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
9260 }
9261 
9262 static inline void
vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)9263 vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
9264 {
9265     VkStructureType stype;
9266     vn_decode_VkStructureType(dec, &stype);
9267     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
9268 
9269     assert(val->sType == stype);
9270     vn_decode_VkExternalImageFormatProperties_pnext(dec, val->pNext);
9271     vn_decode_VkExternalImageFormatProperties_self(dec, val);
9272 }
9273 
9274 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void * val)9275 vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void *val)
9276 {
9277     /* no known/supported struct */
9278     return vn_sizeof_simple_pointer(NULL);
9279 }
9280 
9281 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties * val)9282 vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties *val)
9283 {
9284     size_t size = 0;
9285     /* skip val->{sType,pNext} */
9286     size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
9287     return size;
9288 }
9289 
9290 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties * val)9291 vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties *val)
9292 {
9293     size_t size = 0;
9294 
9295     size += vn_sizeof_VkStructureType(&val->sType);
9296     size += vn_sizeof_VkExternalImageFormatProperties_pnext_partial(val->pNext);
9297     size += vn_sizeof_VkExternalImageFormatProperties_self_partial(val);
9298 
9299     return size;
9300 }
9301 
9302 static inline void
vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)9303 vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9304 {
9305     /* no known/supported struct */
9306     vn_encode_simple_pointer(enc, NULL);
9307 }
9308 
9309 static inline void
vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)9310 vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
9311 {
9312     /* skip val->{sType,pNext} */
9313     vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
9314 }
9315 
9316 static inline void
vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)9317 vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
9318 {
9319     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
9320     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES });
9321     vn_encode_VkExternalImageFormatProperties_pnext_partial(enc, val->pNext);
9322     vn_encode_VkExternalImageFormatProperties_self_partial(enc, val);
9323 }
9324 
9325 /* struct VkSamplerYcbcrConversionImageFormatProperties chain */
9326 
9327 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void * val)9328 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void *val)
9329 {
9330     /* no known/supported struct */
9331     return vn_sizeof_simple_pointer(NULL);
9332 }
9333 
9334 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties * val)9335 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties *val)
9336 {
9337     size_t size = 0;
9338     /* skip val->{sType,pNext} */
9339     size += vn_sizeof_uint32_t(&val->combinedImageSamplerDescriptorCount);
9340     return size;
9341 }
9342 
9343 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * val)9344 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties *val)
9345 {
9346     size_t size = 0;
9347 
9348     size += vn_sizeof_VkStructureType(&val->sType);
9349     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(val->pNext);
9350     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(val);
9351 
9352     return size;
9353 }
9354 
9355 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)9356 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
9357 {
9358     /* no known/supported struct */
9359     if (vn_decode_simple_pointer(dec))
9360         assert(false);
9361 }
9362 
9363 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)9364 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
9365 {
9366     /* skip val->{sType,pNext} */
9367     vn_decode_uint32_t(dec, &val->combinedImageSamplerDescriptorCount);
9368 }
9369 
9370 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)9371 vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
9372 {
9373     VkStructureType stype;
9374     vn_decode_VkStructureType(dec, &stype);
9375     assert(stype == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
9376 
9377     assert(val->sType == stype);
9378     vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(dec, val->pNext);
9379     vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, val);
9380 }
9381 
9382 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void * val)9383 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void *val)
9384 {
9385     /* no known/supported struct */
9386     return vn_sizeof_simple_pointer(NULL);
9387 }
9388 
9389 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)9390 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
9391 {
9392     size_t size = 0;
9393     /* skip val->{sType,pNext} */
9394     /* skip val->combinedImageSamplerDescriptorCount */
9395     return size;
9396 }
9397 
9398 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)9399 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
9400 {
9401     size_t size = 0;
9402 
9403     size += vn_sizeof_VkStructureType(&val->sType);
9404     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(val->pNext);
9405     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(val);
9406 
9407     return size;
9408 }
9409 
9410 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)9411 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9412 {
9413     /* no known/supported struct */
9414     vn_encode_simple_pointer(enc, NULL);
9415 }
9416 
9417 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)9418 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
9419 {
9420     /* skip val->{sType,pNext} */
9421     /* skip val->combinedImageSamplerDescriptorCount */
9422 }
9423 
9424 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)9425 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
9426 {
9427     assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
9428     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES });
9429     vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(enc, val->pNext);
9430     vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, val);
9431 }
9432 
9433 /* struct VkImageFormatProperties2 chain */
9434 
9435 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext(const void * val)9436 vn_sizeof_VkImageFormatProperties2_pnext(const void *val)
9437 {
9438     const VkBaseInStructure *pnext = val;
9439     size_t size = 0;
9440 
9441     while (pnext) {
9442         switch ((int32_t)pnext->sType) {
9443         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9444             size += vn_sizeof_simple_pointer(pnext);
9445             size += vn_sizeof_VkStructureType(&pnext->sType);
9446             size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
9447             size += vn_sizeof_VkExternalImageFormatProperties_self((const VkExternalImageFormatProperties *)pnext);
9448             return size;
9449         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9450             size += vn_sizeof_simple_pointer(pnext);
9451             size += vn_sizeof_VkStructureType(&pnext->sType);
9452             size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
9453             size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9454             return size;
9455         default:
9456             /* ignore unknown/unsupported struct */
9457             break;
9458         }
9459         pnext = pnext->pNext;
9460     }
9461 
9462     return vn_sizeof_simple_pointer(NULL);
9463 }
9464 
9465 static inline size_t
vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 * val)9466 vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 *val)
9467 {
9468     size_t size = 0;
9469     /* skip val->{sType,pNext} */
9470     size += vn_sizeof_VkImageFormatProperties(&val->imageFormatProperties);
9471     return size;
9472 }
9473 
9474 static inline size_t
vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 * val)9475 vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 *val)
9476 {
9477     size_t size = 0;
9478 
9479     size += vn_sizeof_VkStructureType(&val->sType);
9480     size += vn_sizeof_VkImageFormatProperties2_pnext(val->pNext);
9481     size += vn_sizeof_VkImageFormatProperties2_self(val);
9482 
9483     return size;
9484 }
9485 
9486 static inline void
vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9487 vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9488 {
9489     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
9490     VkStructureType stype;
9491 
9492     if (!vn_decode_simple_pointer(dec))
9493         return;
9494 
9495     vn_decode_VkStructureType(dec, &stype);
9496     while (true) {
9497         assert(pnext);
9498         if (pnext->sType == stype)
9499             break;
9500     }
9501 
9502     switch ((int32_t)pnext->sType) {
9503     case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9504         vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
9505         vn_decode_VkExternalImageFormatProperties_self(dec, (VkExternalImageFormatProperties *)pnext);
9506         break;
9507     case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9508         vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
9509         vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9510         break;
9511     default:
9512         assert(false);
9513         break;
9514     }
9515 }
9516 
9517 static inline void
vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)9518 vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
9519 {
9520     /* skip val->{sType,pNext} */
9521     vn_decode_VkImageFormatProperties(dec, &val->imageFormatProperties);
9522 }
9523 
9524 static inline void
vn_decode_VkImageFormatProperties2(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)9525 vn_decode_VkImageFormatProperties2(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
9526 {
9527     VkStructureType stype;
9528     vn_decode_VkStructureType(dec, &stype);
9529     assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
9530 
9531     assert(val->sType == stype);
9532     vn_decode_VkImageFormatProperties2_pnext(dec, val->pNext);
9533     vn_decode_VkImageFormatProperties2_self(dec, val);
9534 }
9535 
9536 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext_partial(const void * val)9537 vn_sizeof_VkImageFormatProperties2_pnext_partial(const void *val)
9538 {
9539     const VkBaseInStructure *pnext = val;
9540     size_t size = 0;
9541 
9542     while (pnext) {
9543         switch ((int32_t)pnext->sType) {
9544         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9545             size += vn_sizeof_simple_pointer(pnext);
9546             size += vn_sizeof_VkStructureType(&pnext->sType);
9547             size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
9548             size += vn_sizeof_VkExternalImageFormatProperties_self_partial((const VkExternalImageFormatProperties *)pnext);
9549             return size;
9550         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9551             size += vn_sizeof_simple_pointer(pnext);
9552             size += vn_sizeof_VkStructureType(&pnext->sType);
9553             size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
9554             size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9555             return size;
9556         default:
9557             /* ignore unknown/unsupported struct */
9558             break;
9559         }
9560         pnext = pnext->pNext;
9561     }
9562 
9563     return vn_sizeof_simple_pointer(NULL);
9564 }
9565 
9566 static inline size_t
vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 * val)9567 vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 *val)
9568 {
9569     size_t size = 0;
9570     /* skip val->{sType,pNext} */
9571     size += vn_sizeof_VkImageFormatProperties_partial(&val->imageFormatProperties);
9572     return size;
9573 }
9574 
9575 static inline size_t
vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 * val)9576 vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 *val)
9577 {
9578     size_t size = 0;
9579 
9580     size += vn_sizeof_VkStructureType(&val->sType);
9581     size += vn_sizeof_VkImageFormatProperties2_pnext_partial(val->pNext);
9582     size += vn_sizeof_VkImageFormatProperties2_self_partial(val);
9583 
9584     return size;
9585 }
9586 
9587 static inline void
vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9588 vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9589 {
9590     const VkBaseInStructure *pnext = val;
9591 
9592     while (pnext) {
9593         switch ((int32_t)pnext->sType) {
9594         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
9595             vn_encode_simple_pointer(enc, pnext);
9596             vn_encode_VkStructureType(enc, &pnext->sType);
9597             vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
9598             vn_encode_VkExternalImageFormatProperties_self_partial(enc, (const VkExternalImageFormatProperties *)pnext);
9599             return;
9600         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
9601             vn_encode_simple_pointer(enc, pnext);
9602             vn_encode_VkStructureType(enc, &pnext->sType);
9603             vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
9604             vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
9605             return;
9606         default:
9607             /* ignore unknown/unsupported struct */
9608             break;
9609         }
9610         pnext = pnext->pNext;
9611     }
9612 
9613     vn_encode_simple_pointer(enc, NULL);
9614 }
9615 
9616 static inline void
vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)9617 vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
9618 {
9619     /* skip val->{sType,pNext} */
9620     vn_encode_VkImageFormatProperties_partial(enc, &val->imageFormatProperties);
9621 }
9622 
9623 static inline void
vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)9624 vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
9625 {
9626     assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
9627     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 });
9628     vn_encode_VkImageFormatProperties2_pnext_partial(enc, val->pNext);
9629     vn_encode_VkImageFormatProperties2_self_partial(enc, val);
9630 }
9631 
9632 /* struct VkQueueFamilyProperties2 chain */
9633 
9634 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext(const void * val)9635 vn_sizeof_VkQueueFamilyProperties2_pnext(const void *val)
9636 {
9637     /* no known/supported struct */
9638     return vn_sizeof_simple_pointer(NULL);
9639 }
9640 
9641 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 * val)9642 vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 *val)
9643 {
9644     size_t size = 0;
9645     /* skip val->{sType,pNext} */
9646     size += vn_sizeof_VkQueueFamilyProperties(&val->queueFamilyProperties);
9647     return size;
9648 }
9649 
9650 static inline size_t
vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * val)9651 vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *val)
9652 {
9653     size_t size = 0;
9654 
9655     size += vn_sizeof_VkStructureType(&val->sType);
9656     size += vn_sizeof_VkQueueFamilyProperties2_pnext(val->pNext);
9657     size += vn_sizeof_VkQueueFamilyProperties2_self(val);
9658 
9659     return size;
9660 }
9661 
9662 static inline void
vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9663 vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9664 {
9665     /* no known/supported struct */
9666     if (vn_decode_simple_pointer(dec))
9667         assert(false);
9668 }
9669 
9670 static inline void
vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)9671 vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
9672 {
9673     /* skip val->{sType,pNext} */
9674     vn_decode_VkQueueFamilyProperties(dec, &val->queueFamilyProperties);
9675 }
9676 
9677 static inline void
vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)9678 vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
9679 {
9680     VkStructureType stype;
9681     vn_decode_VkStructureType(dec, &stype);
9682     assert(stype == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
9683 
9684     assert(val->sType == stype);
9685     vn_decode_VkQueueFamilyProperties2_pnext(dec, val->pNext);
9686     vn_decode_VkQueueFamilyProperties2_self(dec, val);
9687 }
9688 
9689 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void * val)9690 vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void *val)
9691 {
9692     /* no known/supported struct */
9693     return vn_sizeof_simple_pointer(NULL);
9694 }
9695 
9696 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 * val)9697 vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 *val)
9698 {
9699     size_t size = 0;
9700     /* skip val->{sType,pNext} */
9701     size += vn_sizeof_VkQueueFamilyProperties_partial(&val->queueFamilyProperties);
9702     return size;
9703 }
9704 
9705 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 * val)9706 vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 *val)
9707 {
9708     size_t size = 0;
9709 
9710     size += vn_sizeof_VkStructureType(&val->sType);
9711     size += vn_sizeof_VkQueueFamilyProperties2_pnext_partial(val->pNext);
9712     size += vn_sizeof_VkQueueFamilyProperties2_self_partial(val);
9713 
9714     return size;
9715 }
9716 
9717 static inline void
vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9718 vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9719 {
9720     /* no known/supported struct */
9721     vn_encode_simple_pointer(enc, NULL);
9722 }
9723 
9724 static inline void
vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)9725 vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
9726 {
9727     /* skip val->{sType,pNext} */
9728     vn_encode_VkQueueFamilyProperties_partial(enc, &val->queueFamilyProperties);
9729 }
9730 
9731 static inline void
vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)9732 vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
9733 {
9734     assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
9735     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 });
9736     vn_encode_VkQueueFamilyProperties2_pnext_partial(enc, val->pNext);
9737     vn_encode_VkQueueFamilyProperties2_self_partial(enc, val);
9738 }
9739 
9740 /* struct VkPhysicalDeviceMemoryProperties2 chain */
9741 
9742 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void * val)9743 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void *val)
9744 {
9745     /* no known/supported struct */
9746     return vn_sizeof_simple_pointer(NULL);
9747 }
9748 
9749 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 * val)9750 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 *val)
9751 {
9752     size_t size = 0;
9753     /* skip val->{sType,pNext} */
9754     size += vn_sizeof_VkPhysicalDeviceMemoryProperties(&val->memoryProperties);
9755     return size;
9756 }
9757 
9758 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * val)9759 vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *val)
9760 {
9761     size_t size = 0;
9762 
9763     size += vn_sizeof_VkStructureType(&val->sType);
9764     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(val->pNext);
9765     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(val);
9766 
9767     return size;
9768 }
9769 
9770 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9771 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9772 {
9773     /* no known/supported struct */
9774     if (vn_decode_simple_pointer(dec))
9775         assert(false);
9776 }
9777 
9778 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)9779 vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
9780 {
9781     /* skip val->{sType,pNext} */
9782     vn_decode_VkPhysicalDeviceMemoryProperties(dec, &val->memoryProperties);
9783 }
9784 
9785 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)9786 vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
9787 {
9788     VkStructureType stype;
9789     vn_decode_VkStructureType(dec, &stype);
9790     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
9791 
9792     assert(val->sType == stype);
9793     vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, val->pNext);
9794     vn_decode_VkPhysicalDeviceMemoryProperties2_self(dec, val);
9795 }
9796 
9797 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void * val)9798 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void *val)
9799 {
9800     /* no known/supported struct */
9801     return vn_sizeof_simple_pointer(NULL);
9802 }
9803 
9804 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 * val)9805 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 *val)
9806 {
9807     size_t size = 0;
9808     /* skip val->{sType,pNext} */
9809     size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(&val->memoryProperties);
9810     return size;
9811 }
9812 
9813 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 * val)9814 vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 *val)
9815 {
9816     size_t size = 0;
9817 
9818     size += vn_sizeof_VkStructureType(&val->sType);
9819     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(val->pNext);
9820     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(val);
9821 
9822     return size;
9823 }
9824 
9825 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9826 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9827 {
9828     /* no known/supported struct */
9829     vn_encode_simple_pointer(enc, NULL);
9830 }
9831 
9832 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)9833 vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
9834 {
9835     /* skip val->{sType,pNext} */
9836     vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, &val->memoryProperties);
9837 }
9838 
9839 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)9840 vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
9841 {
9842     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
9843     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 });
9844     vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, val->pNext);
9845     vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(enc, val);
9846 }
9847 
9848 /* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */
9849 
9850 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void * val)9851 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void *val)
9852 {
9853     /* no known/supported struct */
9854     return vn_sizeof_simple_pointer(NULL);
9855 }
9856 
9857 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 * val)9858 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9859 {
9860     size_t size = 0;
9861     /* skip val->{sType,pNext} */
9862     size += vn_sizeof_VkFormat(&val->format);
9863     size += vn_sizeof_VkImageType(&val->type);
9864     size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
9865     size += vn_sizeof_VkFlags(&val->usage);
9866     size += vn_sizeof_VkImageTiling(&val->tiling);
9867     return size;
9868 }
9869 
9870 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 * val)9871 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9872 {
9873     size_t size = 0;
9874 
9875     size += vn_sizeof_VkStructureType(&val->sType);
9876     size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(val->pNext);
9877     size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(val);
9878 
9879     return size;
9880 }
9881 
9882 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)9883 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
9884 {
9885     /* no known/supported struct */
9886     vn_encode_simple_pointer(enc, NULL);
9887 }
9888 
9889 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)9890 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9891 {
9892     /* skip val->{sType,pNext} */
9893     vn_encode_VkFormat(enc, &val->format);
9894     vn_encode_VkImageType(enc, &val->type);
9895     vn_encode_VkSampleCountFlagBits(enc, &val->samples);
9896     vn_encode_VkFlags(enc, &val->usage);
9897     vn_encode_VkImageTiling(enc, &val->tiling);
9898 }
9899 
9900 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)9901 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
9902 {
9903     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2);
9904     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 });
9905     vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(enc, val->pNext);
9906     vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(enc, val);
9907 }
9908 
9909 /* struct VkSparseImageFormatProperties2 chain */
9910 
9911 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext(const void * val)9912 vn_sizeof_VkSparseImageFormatProperties2_pnext(const void *val)
9913 {
9914     /* no known/supported struct */
9915     return vn_sizeof_simple_pointer(NULL);
9916 }
9917 
9918 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 * val)9919 vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 *val)
9920 {
9921     size_t size = 0;
9922     /* skip val->{sType,pNext} */
9923     size += vn_sizeof_VkSparseImageFormatProperties(&val->properties);
9924     return size;
9925 }
9926 
9927 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 * val)9928 vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 *val)
9929 {
9930     size_t size = 0;
9931 
9932     size += vn_sizeof_VkStructureType(&val->sType);
9933     size += vn_sizeof_VkSparseImageFormatProperties2_pnext(val->pNext);
9934     size += vn_sizeof_VkSparseImageFormatProperties2_self(val);
9935 
9936     return size;
9937 }
9938 
9939 static inline void
vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)9940 vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
9941 {
9942     /* no known/supported struct */
9943     if (vn_decode_simple_pointer(dec))
9944         assert(false);
9945 }
9946 
9947 static inline void
vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)9948 vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
9949 {
9950     /* skip val->{sType,pNext} */
9951     vn_decode_VkSparseImageFormatProperties(dec, &val->properties);
9952 }
9953 
9954 static inline void
vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)9955 vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
9956 {
9957     VkStructureType stype;
9958     vn_decode_VkStructureType(dec, &stype);
9959     assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
9960 
9961     assert(val->sType == stype);
9962     vn_decode_VkSparseImageFormatProperties2_pnext(dec, val->pNext);
9963     vn_decode_VkSparseImageFormatProperties2_self(dec, val);
9964 }
9965 
9966 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void * val)9967 vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void *val)
9968 {
9969     /* no known/supported struct */
9970     return vn_sizeof_simple_pointer(NULL);
9971 }
9972 
9973 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 * val)9974 vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 *val)
9975 {
9976     size_t size = 0;
9977     /* skip val->{sType,pNext} */
9978     size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->properties);
9979     return size;
9980 }
9981 
9982 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 * val)9983 vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 *val)
9984 {
9985     size_t size = 0;
9986 
9987     size += vn_sizeof_VkStructureType(&val->sType);
9988     size += vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(val->pNext);
9989     size += vn_sizeof_VkSparseImageFormatProperties2_self_partial(val);
9990 
9991     return size;
9992 }
9993 
9994 static inline void
vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9995 vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9996 {
9997     /* no known/supported struct */
9998     vn_encode_simple_pointer(enc, NULL);
9999 }
10000 
10001 static inline void
vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)10002 vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
10003 {
10004     /* skip val->{sType,pNext} */
10005     vn_encode_VkSparseImageFormatProperties_partial(enc, &val->properties);
10006 }
10007 
10008 static inline void
vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)10009 vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
10010 {
10011     assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
10012     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 });
10013     vn_encode_VkSparseImageFormatProperties2_pnext_partial(enc, val->pNext);
10014     vn_encode_VkSparseImageFormatProperties2_self_partial(enc, val);
10015 }
10016 
10017 /* struct VkPhysicalDeviceExternalBufferInfo chain */
10018 
10019 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void * val)10020 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void *val)
10021 {
10022     /* no known/supported struct */
10023     return vn_sizeof_simple_pointer(NULL);
10024 }
10025 
10026 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo * val)10027 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo *val)
10028 {
10029     size_t size = 0;
10030     /* skip val->{sType,pNext} */
10031     size += vn_sizeof_VkFlags(&val->flags);
10032     size += vn_sizeof_VkFlags(&val->usage);
10033     size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
10034     return size;
10035 }
10036 
10037 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * val)10038 vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *val)
10039 {
10040     size_t size = 0;
10041 
10042     size += vn_sizeof_VkStructureType(&val->sType);
10043     size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(val->pNext);
10044     size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(val);
10045 
10046     return size;
10047 }
10048 
10049 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder * enc,const void * val)10050 vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10051 {
10052     /* no known/supported struct */
10053     vn_encode_simple_pointer(enc, NULL);
10054 }
10055 
10056 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)10057 vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
10058 {
10059     /* skip val->{sType,pNext} */
10060     vn_encode_VkFlags(enc, &val->flags);
10061     vn_encode_VkFlags(enc, &val->usage);
10062     vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
10063 }
10064 
10065 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)10066 vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
10067 {
10068     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO);
10069     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO });
10070     vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, val->pNext);
10071     vn_encode_VkPhysicalDeviceExternalBufferInfo_self(enc, val);
10072 }
10073 
10074 /* struct VkExternalBufferProperties chain */
10075 
10076 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext(const void * val)10077 vn_sizeof_VkExternalBufferProperties_pnext(const void *val)
10078 {
10079     /* no known/supported struct */
10080     return vn_sizeof_simple_pointer(NULL);
10081 }
10082 
10083 static inline size_t
vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties * val)10084 vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties *val)
10085 {
10086     size_t size = 0;
10087     /* skip val->{sType,pNext} */
10088     size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
10089     return size;
10090 }
10091 
10092 static inline size_t
vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties * val)10093 vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties *val)
10094 {
10095     size_t size = 0;
10096 
10097     size += vn_sizeof_VkStructureType(&val->sType);
10098     size += vn_sizeof_VkExternalBufferProperties_pnext(val->pNext);
10099     size += vn_sizeof_VkExternalBufferProperties_self(val);
10100 
10101     return size;
10102 }
10103 
10104 static inline void
vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder * dec,const void * val)10105 vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10106 {
10107     /* no known/supported struct */
10108     if (vn_decode_simple_pointer(dec))
10109         assert(false);
10110 }
10111 
10112 static inline void
vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)10113 vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
10114 {
10115     /* skip val->{sType,pNext} */
10116     vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
10117 }
10118 
10119 static inline void
vn_decode_VkExternalBufferProperties(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)10120 vn_decode_VkExternalBufferProperties(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
10121 {
10122     VkStructureType stype;
10123     vn_decode_VkStructureType(dec, &stype);
10124     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
10125 
10126     assert(val->sType == stype);
10127     vn_decode_VkExternalBufferProperties_pnext(dec, val->pNext);
10128     vn_decode_VkExternalBufferProperties_self(dec, val);
10129 }
10130 
10131 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext_partial(const void * val)10132 vn_sizeof_VkExternalBufferProperties_pnext_partial(const void *val)
10133 {
10134     /* no known/supported struct */
10135     return vn_sizeof_simple_pointer(NULL);
10136 }
10137 
10138 static inline size_t
vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties * val)10139 vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties *val)
10140 {
10141     size_t size = 0;
10142     /* skip val->{sType,pNext} */
10143     size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
10144     return size;
10145 }
10146 
10147 static inline size_t
vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties * val)10148 vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties *val)
10149 {
10150     size_t size = 0;
10151 
10152     size += vn_sizeof_VkStructureType(&val->sType);
10153     size += vn_sizeof_VkExternalBufferProperties_pnext_partial(val->pNext);
10154     size += vn_sizeof_VkExternalBufferProperties_self_partial(val);
10155 
10156     return size;
10157 }
10158 
10159 static inline void
vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10160 vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10161 {
10162     /* no known/supported struct */
10163     vn_encode_simple_pointer(enc, NULL);
10164 }
10165 
10166 static inline void
vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)10167 vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
10168 {
10169     /* skip val->{sType,pNext} */
10170     vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
10171 }
10172 
10173 static inline void
vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)10174 vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
10175 {
10176     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
10177     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES });
10178     vn_encode_VkExternalBufferProperties_pnext_partial(enc, val->pNext);
10179     vn_encode_VkExternalBufferProperties_self_partial(enc, val);
10180 }
10181 
10182 /* struct VkPhysicalDeviceExternalSemaphoreInfo chain */
10183 
10184 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void * val)10185 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void *val)
10186 {
10187     const VkBaseInStructure *pnext = val;
10188     size_t size = 0;
10189 
10190     while (pnext) {
10191         switch ((int32_t)pnext->sType) {
10192         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
10193             size += vn_sizeof_simple_pointer(pnext);
10194             size += vn_sizeof_VkStructureType(&pnext->sType);
10195             size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(pnext->pNext);
10196             size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
10197             return size;
10198         default:
10199             /* ignore unknown/unsupported struct */
10200             break;
10201         }
10202         pnext = pnext->pNext;
10203     }
10204 
10205     return vn_sizeof_simple_pointer(NULL);
10206 }
10207 
10208 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo * val)10209 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo *val)
10210 {
10211     size_t size = 0;
10212     /* skip val->{sType,pNext} */
10213     size += vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(&val->handleType);
10214     return size;
10215 }
10216 
10217 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * val)10218 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *val)
10219 {
10220     size_t size = 0;
10221 
10222     size += vn_sizeof_VkStructureType(&val->sType);
10223     size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(val->pNext);
10224     size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(val);
10225 
10226     return size;
10227 }
10228 
10229 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder * enc,const void * val)10230 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10231 {
10232     const VkBaseInStructure *pnext = val;
10233 
10234     while (pnext) {
10235         switch ((int32_t)pnext->sType) {
10236         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
10237             vn_encode_simple_pointer(enc, pnext);
10238             vn_encode_VkStructureType(enc, &pnext->sType);
10239             vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, pnext->pNext);
10240             vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
10241             return;
10242         default:
10243             /* ignore unknown/unsupported struct */
10244             break;
10245         }
10246         pnext = pnext->pNext;
10247     }
10248 
10249     vn_encode_simple_pointer(enc, NULL);
10250 }
10251 
10252 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)10253 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
10254 {
10255     /* skip val->{sType,pNext} */
10256     vn_encode_VkExternalSemaphoreHandleTypeFlagBits(enc, &val->handleType);
10257 }
10258 
10259 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)10260 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
10261 {
10262     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
10263     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO });
10264     vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, val->pNext);
10265     vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(enc, val);
10266 }
10267 
10268 /* struct VkExternalSemaphoreProperties chain */
10269 
10270 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext(const void * val)10271 vn_sizeof_VkExternalSemaphoreProperties_pnext(const void *val)
10272 {
10273     /* no known/supported struct */
10274     return vn_sizeof_simple_pointer(NULL);
10275 }
10276 
10277 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties * val)10278 vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties *val)
10279 {
10280     size_t size = 0;
10281     /* skip val->{sType,pNext} */
10282     size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
10283     size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
10284     size += vn_sizeof_VkFlags(&val->externalSemaphoreFeatures);
10285     return size;
10286 }
10287 
10288 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * val)10289 vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *val)
10290 {
10291     size_t size = 0;
10292 
10293     size += vn_sizeof_VkStructureType(&val->sType);
10294     size += vn_sizeof_VkExternalSemaphoreProperties_pnext(val->pNext);
10295     size += vn_sizeof_VkExternalSemaphoreProperties_self(val);
10296 
10297     return size;
10298 }
10299 
10300 static inline void
vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)10301 vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10302 {
10303     /* no known/supported struct */
10304     if (vn_decode_simple_pointer(dec))
10305         assert(false);
10306 }
10307 
10308 static inline void
vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)10309 vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
10310 {
10311     /* skip val->{sType,pNext} */
10312     vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
10313     vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
10314     vn_decode_VkFlags(dec, &val->externalSemaphoreFeatures);
10315 }
10316 
10317 static inline void
vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)10318 vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
10319 {
10320     VkStructureType stype;
10321     vn_decode_VkStructureType(dec, &stype);
10322     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
10323 
10324     assert(val->sType == stype);
10325     vn_decode_VkExternalSemaphoreProperties_pnext(dec, val->pNext);
10326     vn_decode_VkExternalSemaphoreProperties_self(dec, val);
10327 }
10328 
10329 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void * val)10330 vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void *val)
10331 {
10332     /* no known/supported struct */
10333     return vn_sizeof_simple_pointer(NULL);
10334 }
10335 
10336 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties * val)10337 vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties *val)
10338 {
10339     size_t size = 0;
10340     /* skip val->{sType,pNext} */
10341     /* skip val->exportFromImportedHandleTypes */
10342     /* skip val->compatibleHandleTypes */
10343     /* skip val->externalSemaphoreFeatures */
10344     return size;
10345 }
10346 
10347 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties * val)10348 vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties *val)
10349 {
10350     size_t size = 0;
10351 
10352     size += vn_sizeof_VkStructureType(&val->sType);
10353     size += vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(val->pNext);
10354     size += vn_sizeof_VkExternalSemaphoreProperties_self_partial(val);
10355 
10356     return size;
10357 }
10358 
10359 static inline void
vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10360 vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10361 {
10362     /* no known/supported struct */
10363     vn_encode_simple_pointer(enc, NULL);
10364 }
10365 
10366 static inline void
vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)10367 vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
10368 {
10369     /* skip val->{sType,pNext} */
10370     /* skip val->exportFromImportedHandleTypes */
10371     /* skip val->compatibleHandleTypes */
10372     /* skip val->externalSemaphoreFeatures */
10373 }
10374 
10375 static inline void
vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)10376 vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
10377 {
10378     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
10379     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES });
10380     vn_encode_VkExternalSemaphoreProperties_pnext_partial(enc, val->pNext);
10381     vn_encode_VkExternalSemaphoreProperties_self_partial(enc, val);
10382 }
10383 
10384 /* struct VkPhysicalDeviceExternalFenceInfo chain */
10385 
10386 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void * val)10387 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void *val)
10388 {
10389     /* no known/supported struct */
10390     return vn_sizeof_simple_pointer(NULL);
10391 }
10392 
10393 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo * val)10394 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo *val)
10395 {
10396     size_t size = 0;
10397     /* skip val->{sType,pNext} */
10398     size += vn_sizeof_VkExternalFenceHandleTypeFlagBits(&val->handleType);
10399     return size;
10400 }
10401 
10402 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * val)10403 vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *val)
10404 {
10405     size_t size = 0;
10406 
10407     size += vn_sizeof_VkStructureType(&val->sType);
10408     size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(val->pNext);
10409     size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(val);
10410 
10411     return size;
10412 }
10413 
10414 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder * enc,const void * val)10415 vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10416 {
10417     /* no known/supported struct */
10418     vn_encode_simple_pointer(enc, NULL);
10419 }
10420 
10421 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)10422 vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
10423 {
10424     /* skip val->{sType,pNext} */
10425     vn_encode_VkExternalFenceHandleTypeFlagBits(enc, &val->handleType);
10426 }
10427 
10428 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)10429 vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
10430 {
10431     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO);
10432     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO });
10433     vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(enc, val->pNext);
10434     vn_encode_VkPhysicalDeviceExternalFenceInfo_self(enc, val);
10435 }
10436 
10437 /* struct VkExternalFenceProperties chain */
10438 
10439 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext(const void * val)10440 vn_sizeof_VkExternalFenceProperties_pnext(const void *val)
10441 {
10442     /* no known/supported struct */
10443     return vn_sizeof_simple_pointer(NULL);
10444 }
10445 
10446 static inline size_t
vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties * val)10447 vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties *val)
10448 {
10449     size_t size = 0;
10450     /* skip val->{sType,pNext} */
10451     size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
10452     size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
10453     size += vn_sizeof_VkFlags(&val->externalFenceFeatures);
10454     return size;
10455 }
10456 
10457 static inline size_t
vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties * val)10458 vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties *val)
10459 {
10460     size_t size = 0;
10461 
10462     size += vn_sizeof_VkStructureType(&val->sType);
10463     size += vn_sizeof_VkExternalFenceProperties_pnext(val->pNext);
10464     size += vn_sizeof_VkExternalFenceProperties_self(val);
10465 
10466     return size;
10467 }
10468 
10469 static inline void
vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder * dec,const void * val)10470 vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10471 {
10472     /* no known/supported struct */
10473     if (vn_decode_simple_pointer(dec))
10474         assert(false);
10475 }
10476 
10477 static inline void
vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)10478 vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
10479 {
10480     /* skip val->{sType,pNext} */
10481     vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
10482     vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
10483     vn_decode_VkFlags(dec, &val->externalFenceFeatures);
10484 }
10485 
10486 static inline void
vn_decode_VkExternalFenceProperties(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)10487 vn_decode_VkExternalFenceProperties(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
10488 {
10489     VkStructureType stype;
10490     vn_decode_VkStructureType(dec, &stype);
10491     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
10492 
10493     assert(val->sType == stype);
10494     vn_decode_VkExternalFenceProperties_pnext(dec, val->pNext);
10495     vn_decode_VkExternalFenceProperties_self(dec, val);
10496 }
10497 
10498 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext_partial(const void * val)10499 vn_sizeof_VkExternalFenceProperties_pnext_partial(const void *val)
10500 {
10501     /* no known/supported struct */
10502     return vn_sizeof_simple_pointer(NULL);
10503 }
10504 
10505 static inline size_t
vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties * val)10506 vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties *val)
10507 {
10508     size_t size = 0;
10509     /* skip val->{sType,pNext} */
10510     /* skip val->exportFromImportedHandleTypes */
10511     /* skip val->compatibleHandleTypes */
10512     /* skip val->externalFenceFeatures */
10513     return size;
10514 }
10515 
10516 static inline size_t
vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties * val)10517 vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties *val)
10518 {
10519     size_t size = 0;
10520 
10521     size += vn_sizeof_VkStructureType(&val->sType);
10522     size += vn_sizeof_VkExternalFenceProperties_pnext_partial(val->pNext);
10523     size += vn_sizeof_VkExternalFenceProperties_self_partial(val);
10524 
10525     return size;
10526 }
10527 
10528 static inline void
vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10529 vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10530 {
10531     /* no known/supported struct */
10532     vn_encode_simple_pointer(enc, NULL);
10533 }
10534 
10535 static inline void
vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)10536 vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
10537 {
10538     /* skip val->{sType,pNext} */
10539     /* skip val->exportFromImportedHandleTypes */
10540     /* skip val->compatibleHandleTypes */
10541     /* skip val->externalFenceFeatures */
10542 }
10543 
10544 static inline void
vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)10545 vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
10546 {
10547     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
10548     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES });
10549     vn_encode_VkExternalFenceProperties_pnext_partial(enc, val->pNext);
10550     vn_encode_VkExternalFenceProperties_self_partial(enc, val);
10551 }
10552 
10553 /* struct VkPhysicalDeviceGroupProperties chain */
10554 
10555 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void * val)10556 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void *val)
10557 {
10558     /* no known/supported struct */
10559     return vn_sizeof_simple_pointer(NULL);
10560 }
10561 
10562 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties * val)10563 vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties *val)
10564 {
10565     size_t size = 0;
10566     /* skip val->{sType,pNext} */
10567     size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
10568     size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
10569     for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
10570         size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
10571     size += vn_sizeof_VkBool32(&val->subsetAllocation);
10572     return size;
10573 }
10574 
10575 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * val)10576 vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *val)
10577 {
10578     size_t size = 0;
10579 
10580     size += vn_sizeof_VkStructureType(&val->sType);
10581     size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(val->pNext);
10582     size += vn_sizeof_VkPhysicalDeviceGroupProperties_self(val);
10583 
10584     return size;
10585 }
10586 
10587 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)10588 vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
10589 {
10590     /* no known/supported struct */
10591     if (vn_decode_simple_pointer(dec))
10592         assert(false);
10593 }
10594 
10595 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)10596 vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
10597 {
10598     /* skip val->{sType,pNext} */
10599     vn_decode_uint32_t(dec, &val->physicalDeviceCount);
10600     {
10601         const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE);
10602         for (uint32_t i = 0; i < iter_count; i++)
10603             vn_decode_VkPhysicalDevice(dec, &val->physicalDevices[i]);
10604     }
10605     vn_decode_VkBool32(dec, &val->subsetAllocation);
10606 }
10607 
10608 static inline void
vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)10609 vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
10610 {
10611     VkStructureType stype;
10612     vn_decode_VkStructureType(dec, &stype);
10613     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
10614 
10615     assert(val->sType == stype);
10616     vn_decode_VkPhysicalDeviceGroupProperties_pnext(dec, val->pNext);
10617     vn_decode_VkPhysicalDeviceGroupProperties_self(dec, val);
10618 }
10619 
10620 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void * val)10621 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void *val)
10622 {
10623     /* no known/supported struct */
10624     return vn_sizeof_simple_pointer(NULL);
10625 }
10626 
10627 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties * val)10628 vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties *val)
10629 {
10630     size_t size = 0;
10631     /* skip val->{sType,pNext} */
10632     /* skip val->physicalDeviceCount */
10633     size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
10634     for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
10635         size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
10636     /* skip val->subsetAllocation */
10637     return size;
10638 }
10639 
10640 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties * val)10641 vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties *val)
10642 {
10643     size_t size = 0;
10644 
10645     size += vn_sizeof_VkStructureType(&val->sType);
10646     size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(val->pNext);
10647     size += vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(val);
10648 
10649     return size;
10650 }
10651 
10652 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)10653 vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
10654 {
10655     /* no known/supported struct */
10656     vn_encode_simple_pointer(enc, NULL);
10657 }
10658 
10659 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)10660 vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
10661 {
10662     /* skip val->{sType,pNext} */
10663     /* skip val->physicalDeviceCount */
10664     vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE);
10665     for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
10666         vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]);
10667     /* skip val->subsetAllocation */
10668 }
10669 
10670 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)10671 vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
10672 {
10673     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
10674     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES });
10675     vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(enc, val->pNext);
10676     vn_encode_VkPhysicalDeviceGroupProperties_self_partial(enc, val);
10677 }
10678 
10679 /* struct VkDeviceQueueInfo2 chain */
10680 
10681 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_pnext(const void * val)10682 vn_sizeof_VkDeviceQueueInfo2_pnext(const void *val)
10683 {
10684     /* no known/supported struct */
10685     return vn_sizeof_simple_pointer(NULL);
10686 }
10687 
10688 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 * val)10689 vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 *val)
10690 {
10691     size_t size = 0;
10692     /* skip val->{sType,pNext} */
10693     size += vn_sizeof_VkFlags(&val->flags);
10694     size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
10695     size += vn_sizeof_uint32_t(&val->queueIndex);
10696     return size;
10697 }
10698 
10699 static inline size_t
vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * val)10700 vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *val)
10701 {
10702     size_t size = 0;
10703 
10704     size += vn_sizeof_VkStructureType(&val->sType);
10705     size += vn_sizeof_VkDeviceQueueInfo2_pnext(val->pNext);
10706     size += vn_sizeof_VkDeviceQueueInfo2_self(val);
10707 
10708     return size;
10709 }
10710 
10711 static inline void
vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder * enc,const void * val)10712 vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
10713 {
10714     /* no known/supported struct */
10715     vn_encode_simple_pointer(enc, NULL);
10716 }
10717 
10718 static inline void
vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)10719 vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
10720 {
10721     /* skip val->{sType,pNext} */
10722     vn_encode_VkFlags(enc, &val->flags);
10723     vn_encode_uint32_t(enc, &val->queueFamilyIndex);
10724     vn_encode_uint32_t(enc, &val->queueIndex);
10725 }
10726 
10727 static inline void
vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)10728 vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
10729 {
10730     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2);
10731     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 });
10732     vn_encode_VkDeviceQueueInfo2_pnext(enc, val->pNext);
10733     vn_encode_VkDeviceQueueInfo2_self(enc, val);
10734 }
10735 
vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10736 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10737 {
10738     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
10739     const VkFlags cmd_flags = 0;
10740     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10741 
10742     cmd_size += vn_sizeof_VkInstance(&instance);
10743     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
10744     if (pPhysicalDeviceCount)
10745         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
10746     if (pPhysicalDevices) {
10747         cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10748         for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
10749             cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
10750     } else {
10751         cmd_size += vn_sizeof_array_size(0);
10752     }
10753 
10754     return cmd_size;
10755 }
10756 
vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10757 static inline void vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10758 {
10759     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
10760 
10761     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10762     vn_encode_VkFlags(enc, &cmd_flags);
10763 
10764     vn_encode_VkInstance(enc, &instance);
10765     if (vn_encode_simple_pointer(enc, pPhysicalDeviceCount))
10766         vn_encode_uint32_t(enc, pPhysicalDeviceCount);
10767     if (pPhysicalDevices) {
10768         vn_encode_array_size(enc, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10769         for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
10770             vn_encode_VkPhysicalDevice(enc, &pPhysicalDevices[i]);
10771     } else {
10772         vn_encode_array_size(enc, 0);
10773     }
10774 }
10775 
vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10776 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10777 {
10778     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
10779     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10780 
10781     VkResult ret;
10782     cmd_size += vn_sizeof_VkResult(&ret);
10783     /* skip instance */
10784     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
10785     if (pPhysicalDeviceCount)
10786         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
10787     if (pPhysicalDevices) {
10788         cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10789         for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
10790             cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
10791     } else {
10792         cmd_size += vn_sizeof_array_size(0);
10793     }
10794 
10795     return cmd_size;
10796 }
10797 
vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)10798 static inline VkResult vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
10799 {
10800     VkCommandTypeEXT command_type;
10801     vn_decode_VkCommandTypeEXT(dec, &command_type);
10802     assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT);
10803 
10804     VkResult ret;
10805     vn_decode_VkResult(dec, &ret);
10806     /* skip instance */
10807     if (vn_decode_simple_pointer(dec)) {
10808         vn_decode_uint32_t(dec, pPhysicalDeviceCount);
10809     } else {
10810         pPhysicalDeviceCount = NULL;
10811     }
10812     if (vn_peek_array_size(dec)) {
10813         const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
10814         for (uint32_t i = 0; i < iter_count; i++)
10815             vn_decode_VkPhysicalDevice(dec, &pPhysicalDevices[i]);
10816     } else {
10817         vn_decode_array_size_unchecked(dec);
10818         pPhysicalDevices = NULL;
10819     }
10820 
10821     return ret;
10822 }
10823 
vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10824 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10825 {
10826     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
10827     const VkFlags cmd_flags = 0;
10828     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10829 
10830     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
10831     cmd_size += vn_sizeof_simple_pointer(pProperties);
10832     if (pProperties)
10833         cmd_size += vn_sizeof_VkPhysicalDeviceProperties_partial(pProperties);
10834 
10835     return cmd_size;
10836 }
10837 
vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10838 static inline void vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10839 {
10840     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
10841 
10842     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10843     vn_encode_VkFlags(enc, &cmd_flags);
10844 
10845     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
10846     if (vn_encode_simple_pointer(enc, pProperties))
10847         vn_encode_VkPhysicalDeviceProperties_partial(enc, pProperties);
10848 }
10849 
vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10850 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10851 {
10852     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
10853     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10854 
10855     /* skip physicalDevice */
10856     cmd_size += vn_sizeof_simple_pointer(pProperties);
10857     if (pProperties)
10858         cmd_size += vn_sizeof_VkPhysicalDeviceProperties(pProperties);
10859 
10860     return cmd_size;
10861 }
10862 
vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)10863 static inline void vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
10864 {
10865     VkCommandTypeEXT command_type;
10866     vn_decode_VkCommandTypeEXT(dec, &command_type);
10867     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT);
10868 
10869     /* skip physicalDevice */
10870     if (vn_decode_simple_pointer(dec)) {
10871         vn_decode_VkPhysicalDeviceProperties(dec, pProperties);
10872     } else {
10873         pProperties = NULL;
10874     }
10875 }
10876 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10877 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10878 {
10879     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
10880     const VkFlags cmd_flags = 0;
10881     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10882 
10883     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
10884     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
10885     if (pQueueFamilyPropertyCount)
10886         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
10887     if (pQueueFamilyProperties) {
10888         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10889         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
10890             cmd_size += vn_sizeof_VkQueueFamilyProperties_partial(&pQueueFamilyProperties[i]);
10891     } else {
10892         cmd_size += vn_sizeof_array_size(0);
10893     }
10894 
10895     return cmd_size;
10896 }
10897 
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10898 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10899 {
10900     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
10901 
10902     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10903     vn_encode_VkFlags(enc, &cmd_flags);
10904 
10905     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
10906     if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
10907         vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
10908     if (pQueueFamilyProperties) {
10909         vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10910         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
10911             vn_encode_VkQueueFamilyProperties_partial(enc, &pQueueFamilyProperties[i]);
10912     } else {
10913         vn_encode_array_size(enc, 0);
10914     }
10915 }
10916 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10917 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10918 {
10919     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
10920     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10921 
10922     /* skip physicalDevice */
10923     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
10924     if (pQueueFamilyPropertyCount)
10925         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
10926     if (pQueueFamilyProperties) {
10927         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10928         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
10929             cmd_size += vn_sizeof_VkQueueFamilyProperties(&pQueueFamilyProperties[i]);
10930     } else {
10931         cmd_size += vn_sizeof_array_size(0);
10932     }
10933 
10934     return cmd_size;
10935 }
10936 
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)10937 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
10938 {
10939     VkCommandTypeEXT command_type;
10940     vn_decode_VkCommandTypeEXT(dec, &command_type);
10941     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT);
10942 
10943     /* skip physicalDevice */
10944     if (vn_decode_simple_pointer(dec)) {
10945         vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
10946     } else {
10947         pQueueFamilyPropertyCount = NULL;
10948     }
10949     if (vn_peek_array_size(dec)) {
10950         const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
10951         for (uint32_t i = 0; i < iter_count; i++)
10952             vn_decode_VkQueueFamilyProperties(dec, &pQueueFamilyProperties[i]);
10953     } else {
10954         vn_decode_array_size_unchecked(dec);
10955         pQueueFamilyProperties = NULL;
10956     }
10957 }
10958 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10959 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10960 {
10961     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
10962     const VkFlags cmd_flags = 0;
10963     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
10964 
10965     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
10966     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
10967     if (pMemoryProperties)
10968         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(pMemoryProperties);
10969 
10970     return cmd_size;
10971 }
10972 
vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10973 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10974 {
10975     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
10976 
10977     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
10978     vn_encode_VkFlags(enc, &cmd_flags);
10979 
10980     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
10981     if (vn_encode_simple_pointer(enc, pMemoryProperties))
10982         vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, pMemoryProperties);
10983 }
10984 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10985 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10986 {
10987     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
10988     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
10989 
10990     /* skip physicalDevice */
10991     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
10992     if (pMemoryProperties)
10993         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties(pMemoryProperties);
10994 
10995     return cmd_size;
10996 }
10997 
vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)10998 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
10999 {
11000     VkCommandTypeEXT command_type;
11001     vn_decode_VkCommandTypeEXT(dec, &command_type);
11002     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT);
11003 
11004     /* skip physicalDevice */
11005     if (vn_decode_simple_pointer(dec)) {
11006         vn_decode_VkPhysicalDeviceMemoryProperties(dec, pMemoryProperties);
11007     } else {
11008         pMemoryProperties = NULL;
11009     }
11010 }
11011 
vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11012 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11013 {
11014     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
11015     const VkFlags cmd_flags = 0;
11016     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11017 
11018     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11019     cmd_size += vn_sizeof_simple_pointer(pFeatures);
11020     if (pFeatures)
11021         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures_partial(pFeatures);
11022 
11023     return cmd_size;
11024 }
11025 
vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11026 static inline void vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11027 {
11028     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
11029 
11030     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11031     vn_encode_VkFlags(enc, &cmd_flags);
11032 
11033     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11034     if (vn_encode_simple_pointer(enc, pFeatures))
11035         vn_encode_VkPhysicalDeviceFeatures_partial(enc, pFeatures);
11036 }
11037 
vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11038 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11039 {
11040     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
11041     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11042 
11043     /* skip physicalDevice */
11044     cmd_size += vn_sizeof_simple_pointer(pFeatures);
11045     if (pFeatures)
11046         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures(pFeatures);
11047 
11048     return cmd_size;
11049 }
11050 
vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)11051 static inline void vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
11052 {
11053     VkCommandTypeEXT command_type;
11054     vn_decode_VkCommandTypeEXT(dec, &command_type);
11055     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT);
11056 
11057     /* skip physicalDevice */
11058     if (vn_decode_simple_pointer(dec)) {
11059         vn_decode_VkPhysicalDeviceFeatures(dec, pFeatures);
11060     } else {
11061         pFeatures = NULL;
11062     }
11063 }
11064 
vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11065 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11066 {
11067     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
11068     const VkFlags cmd_flags = 0;
11069     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11070 
11071     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11072     cmd_size += vn_sizeof_VkFormat(&format);
11073     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11074     if (pFormatProperties)
11075         cmd_size += vn_sizeof_VkFormatProperties_partial(pFormatProperties);
11076 
11077     return cmd_size;
11078 }
11079 
vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11080 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11081 {
11082     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
11083 
11084     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11085     vn_encode_VkFlags(enc, &cmd_flags);
11086 
11087     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11088     vn_encode_VkFormat(enc, &format);
11089     if (vn_encode_simple_pointer(enc, pFormatProperties))
11090         vn_encode_VkFormatProperties_partial(enc, pFormatProperties);
11091 }
11092 
vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11093 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11094 {
11095     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
11096     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11097 
11098     /* skip physicalDevice */
11099     /* skip format */
11100     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11101     if (pFormatProperties)
11102         cmd_size += vn_sizeof_VkFormatProperties(pFormatProperties);
11103 
11104     return cmd_size;
11105 }
11106 
vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)11107 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
11108 {
11109     VkCommandTypeEXT command_type;
11110     vn_decode_VkCommandTypeEXT(dec, &command_type);
11111     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT);
11112 
11113     /* skip physicalDevice */
11114     /* skip format */
11115     if (vn_decode_simple_pointer(dec)) {
11116         vn_decode_VkFormatProperties(dec, pFormatProperties);
11117     } else {
11118         pFormatProperties = NULL;
11119     }
11120 }
11121 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11122 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11123 {
11124     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
11125     const VkFlags cmd_flags = 0;
11126     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11127 
11128     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11129     cmd_size += vn_sizeof_VkFormat(&format);
11130     cmd_size += vn_sizeof_VkImageType(&type);
11131     cmd_size += vn_sizeof_VkImageTiling(&tiling);
11132     cmd_size += vn_sizeof_VkFlags(&usage);
11133     cmd_size += vn_sizeof_VkFlags(&flags);
11134     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11135     if (pImageFormatProperties)
11136         cmd_size += vn_sizeof_VkImageFormatProperties_partial(pImageFormatProperties);
11137 
11138     return cmd_size;
11139 }
11140 
vn_encode_vkGetPhysicalDeviceImageFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11141 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11142 {
11143     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
11144 
11145     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11146     vn_encode_VkFlags(enc, &cmd_flags);
11147 
11148     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11149     vn_encode_VkFormat(enc, &format);
11150     vn_encode_VkImageType(enc, &type);
11151     vn_encode_VkImageTiling(enc, &tiling);
11152     vn_encode_VkFlags(enc, &usage);
11153     vn_encode_VkFlags(enc, &flags);
11154     if (vn_encode_simple_pointer(enc, pImageFormatProperties))
11155         vn_encode_VkImageFormatProperties_partial(enc, pImageFormatProperties);
11156 }
11157 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11158 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11159 {
11160     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
11161     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11162 
11163     VkResult ret;
11164     cmd_size += vn_sizeof_VkResult(&ret);
11165     /* skip physicalDevice */
11166     /* skip format */
11167     /* skip type */
11168     /* skip tiling */
11169     /* skip usage */
11170     /* skip flags */
11171     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11172     if (pImageFormatProperties)
11173         cmd_size += vn_sizeof_VkImageFormatProperties(pImageFormatProperties);
11174 
11175     return cmd_size;
11176 }
11177 
vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)11178 static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
11179 {
11180     VkCommandTypeEXT command_type;
11181     vn_decode_VkCommandTypeEXT(dec, &command_type);
11182     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT);
11183 
11184     VkResult ret;
11185     vn_decode_VkResult(dec, &ret);
11186     /* skip physicalDevice */
11187     /* skip format */
11188     /* skip type */
11189     /* skip tiling */
11190     /* skip usage */
11191     /* skip flags */
11192     if (vn_decode_simple_pointer(dec)) {
11193         vn_decode_VkImageFormatProperties(dec, pImageFormatProperties);
11194     } else {
11195         pImageFormatProperties = NULL;
11196     }
11197 
11198     return ret;
11199 }
11200 
vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11201 static inline size_t vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11202 {
11203     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
11204     const VkFlags cmd_flags = 0;
11205     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11206 
11207     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11208     cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
11209     if (pCreateInfo)
11210         cmd_size += vn_sizeof_VkDeviceCreateInfo(pCreateInfo);
11211     cmd_size += vn_sizeof_simple_pointer(pAllocator);
11212     if (pAllocator)
11213         assert(false);
11214     cmd_size += vn_sizeof_simple_pointer(pDevice);
11215     if (pDevice)
11216         cmd_size += vn_sizeof_VkDevice(pDevice);
11217 
11218     return cmd_size;
11219 }
11220 
vn_encode_vkCreateDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11221 static inline void vn_encode_vkCreateDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11222 {
11223     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
11224 
11225     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11226     vn_encode_VkFlags(enc, &cmd_flags);
11227 
11228     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11229     if (vn_encode_simple_pointer(enc, pCreateInfo))
11230         vn_encode_VkDeviceCreateInfo(enc, pCreateInfo);
11231     if (vn_encode_simple_pointer(enc, pAllocator))
11232         assert(false);
11233     if (vn_encode_simple_pointer(enc, pDevice))
11234         vn_encode_VkDevice(enc, pDevice);
11235 }
11236 
vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11237 static inline size_t vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11238 {
11239     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
11240     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11241 
11242     VkResult ret;
11243     cmd_size += vn_sizeof_VkResult(&ret);
11244     /* skip physicalDevice */
11245     /* skip pCreateInfo */
11246     /* skip pAllocator */
11247     cmd_size += vn_sizeof_simple_pointer(pDevice);
11248     if (pDevice)
11249         cmd_size += vn_sizeof_VkDevice(pDevice);
11250 
11251     return cmd_size;
11252 }
11253 
vn_decode_vkCreateDevice_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)11254 static inline VkResult vn_decode_vkCreateDevice_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
11255 {
11256     VkCommandTypeEXT command_type;
11257     vn_decode_VkCommandTypeEXT(dec, &command_type);
11258     assert(command_type == VK_COMMAND_TYPE_vkCreateDevice_EXT);
11259 
11260     VkResult ret;
11261     vn_decode_VkResult(dec, &ret);
11262     /* skip physicalDevice */
11263     /* skip pCreateInfo */
11264     /* skip pAllocator */
11265     if (vn_decode_simple_pointer(dec)) {
11266         vn_decode_VkDevice(dec, pDevice);
11267     } else {
11268         pDevice = NULL;
11269     }
11270 
11271     return ret;
11272 }
11273 
vn_sizeof_vkDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)11274 static inline size_t vn_sizeof_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
11275 {
11276     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
11277     const VkFlags cmd_flags = 0;
11278     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11279 
11280     cmd_size += vn_sizeof_VkDevice(&device);
11281     cmd_size += vn_sizeof_simple_pointer(pAllocator);
11282     if (pAllocator)
11283         assert(false);
11284 
11285     return cmd_size;
11286 }
11287 
vn_encode_vkDestroyDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator)11288 static inline void vn_encode_vkDestroyDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator)
11289 {
11290     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
11291 
11292     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11293     vn_encode_VkFlags(enc, &cmd_flags);
11294 
11295     vn_encode_VkDevice(enc, &device);
11296     if (vn_encode_simple_pointer(enc, pAllocator))
11297         assert(false);
11298 }
11299 
vn_sizeof_vkDestroyDevice_reply(VkDevice device,const VkAllocationCallbacks * pAllocator)11300 static inline size_t vn_sizeof_vkDestroyDevice_reply(VkDevice device, const VkAllocationCallbacks* pAllocator)
11301 {
11302     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
11303     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11304 
11305     /* skip device */
11306     /* skip pAllocator */
11307 
11308     return cmd_size;
11309 }
11310 
vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder * dec,VkDevice device,const VkAllocationCallbacks * pAllocator)11311 static inline void vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder *dec, VkDevice device, const VkAllocationCallbacks* pAllocator)
11312 {
11313     VkCommandTypeEXT command_type;
11314     vn_decode_VkCommandTypeEXT(dec, &command_type);
11315     assert(command_type == VK_COMMAND_TYPE_vkDestroyDevice_EXT);
11316 
11317     /* skip device */
11318     /* skip pAllocator */
11319 }
11320 
vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11321 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11322 {
11323     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
11324     const VkFlags cmd_flags = 0;
11325     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11326 
11327     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11328     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11329     if (pPropertyCount)
11330         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11331     if (pProperties) {
11332         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11333         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11334             cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
11335     } else {
11336         cmd_size += vn_sizeof_array_size(0);
11337     }
11338 
11339     return cmd_size;
11340 }
11341 
vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11342 static inline void vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11343 {
11344     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
11345 
11346     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11347     vn_encode_VkFlags(enc, &cmd_flags);
11348 
11349     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11350     if (vn_encode_simple_pointer(enc, pPropertyCount))
11351         vn_encode_uint32_t(enc, pPropertyCount);
11352     if (pProperties) {
11353         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
11354         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11355             vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
11356     } else {
11357         vn_encode_array_size(enc, 0);
11358     }
11359 }
11360 
vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11361 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11362 {
11363     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
11364     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11365 
11366     VkResult ret;
11367     cmd_size += vn_sizeof_VkResult(&ret);
11368     /* skip physicalDevice */
11369     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11370     if (pPropertyCount)
11371         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11372     if (pProperties) {
11373         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11374         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11375             cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
11376     } else {
11377         cmd_size += vn_sizeof_array_size(0);
11378     }
11379 
11380     return cmd_size;
11381 }
11382 
vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)11383 static inline VkResult vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
11384 {
11385     VkCommandTypeEXT command_type;
11386     vn_decode_VkCommandTypeEXT(dec, &command_type);
11387     assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT);
11388 
11389     VkResult ret;
11390     vn_decode_VkResult(dec, &ret);
11391     /* skip physicalDevice */
11392     if (vn_decode_simple_pointer(dec)) {
11393         vn_decode_uint32_t(dec, pPropertyCount);
11394     } else {
11395         pPropertyCount = NULL;
11396     }
11397     if (vn_peek_array_size(dec)) {
11398         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
11399         for (uint32_t i = 0; i < iter_count; i++)
11400             vn_decode_VkLayerProperties(dec, &pProperties[i]);
11401     } else {
11402         vn_decode_array_size_unchecked(dec);
11403         pProperties = NULL;
11404     }
11405 
11406     return ret;
11407 }
11408 
vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11409 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11410 {
11411     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
11412     const VkFlags cmd_flags = 0;
11413     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11414 
11415     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11416     if (pLayerName) {
11417         const size_t string_size = strlen(pLayerName) + 1;
11418         cmd_size += vn_sizeof_array_size(string_size);
11419         cmd_size += vn_sizeof_char_array(pLayerName, string_size);
11420     } else {
11421         cmd_size += vn_sizeof_array_size(0);
11422     }
11423     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11424     if (pPropertyCount)
11425         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11426     if (pProperties) {
11427         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11428         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11429             cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
11430     } else {
11431         cmd_size += vn_sizeof_array_size(0);
11432     }
11433 
11434     return cmd_size;
11435 }
11436 
vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11437 static inline void vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11438 {
11439     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
11440 
11441     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11442     vn_encode_VkFlags(enc, &cmd_flags);
11443 
11444     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11445     if (pLayerName) {
11446         const size_t string_size = strlen(pLayerName) + 1;
11447         vn_encode_array_size(enc, string_size);
11448         vn_encode_char_array(enc, pLayerName, string_size);
11449     } else {
11450         vn_encode_array_size(enc, 0);
11451     }
11452     if (vn_encode_simple_pointer(enc, pPropertyCount))
11453         vn_encode_uint32_t(enc, pPropertyCount);
11454     if (pProperties) {
11455         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
11456         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11457             vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
11458     } else {
11459         vn_encode_array_size(enc, 0);
11460     }
11461 }
11462 
vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11463 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11464 {
11465     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
11466     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11467 
11468     VkResult ret;
11469     cmd_size += vn_sizeof_VkResult(&ret);
11470     /* skip physicalDevice */
11471     /* skip pLayerName */
11472     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11473     if (pPropertyCount)
11474         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11475     if (pProperties) {
11476         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11477         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11478             cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
11479     } else {
11480         cmd_size += vn_sizeof_array_size(0);
11481     }
11482 
11483     return cmd_size;
11484 }
11485 
vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)11486 static inline VkResult vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
11487 {
11488     VkCommandTypeEXT command_type;
11489     vn_decode_VkCommandTypeEXT(dec, &command_type);
11490     assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT);
11491 
11492     VkResult ret;
11493     vn_decode_VkResult(dec, &ret);
11494     /* skip physicalDevice */
11495     /* skip pLayerName */
11496     if (vn_decode_simple_pointer(dec)) {
11497         vn_decode_uint32_t(dec, pPropertyCount);
11498     } else {
11499         pPropertyCount = NULL;
11500     }
11501     if (vn_peek_array_size(dec)) {
11502         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
11503         for (uint32_t i = 0; i < iter_count; i++)
11504             vn_decode_VkExtensionProperties(dec, &pProperties[i]);
11505     } else {
11506         vn_decode_array_size_unchecked(dec);
11507         pProperties = NULL;
11508     }
11509 
11510     return ret;
11511 }
11512 
vn_sizeof_vkGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11513 static inline size_t vn_sizeof_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11514 {
11515     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
11516     const VkFlags cmd_flags = 0;
11517     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11518 
11519     cmd_size += vn_sizeof_VkDevice(&device);
11520     cmd_size += vn_sizeof_uint32_t(&queueFamilyIndex);
11521     cmd_size += vn_sizeof_uint32_t(&queueIndex);
11522     cmd_size += vn_sizeof_simple_pointer(pQueue);
11523     if (pQueue)
11524         cmd_size += vn_sizeof_VkQueue(pQueue);
11525 
11526     return cmd_size;
11527 }
11528 
vn_encode_vkGetDeviceQueue(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11529 static inline void vn_encode_vkGetDeviceQueue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11530 {
11531     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
11532 
11533     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11534     vn_encode_VkFlags(enc, &cmd_flags);
11535 
11536     vn_encode_VkDevice(enc, &device);
11537     vn_encode_uint32_t(enc, &queueFamilyIndex);
11538     vn_encode_uint32_t(enc, &queueIndex);
11539     if (vn_encode_simple_pointer(enc, pQueue))
11540         vn_encode_VkQueue(enc, pQueue);
11541 }
11542 
vn_sizeof_vkGetDeviceQueue_reply(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11543 static inline size_t vn_sizeof_vkGetDeviceQueue_reply(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11544 {
11545     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
11546     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11547 
11548     /* skip device */
11549     /* skip queueFamilyIndex */
11550     /* skip queueIndex */
11551     cmd_size += vn_sizeof_simple_pointer(pQueue);
11552     if (pQueue)
11553         cmd_size += vn_sizeof_VkQueue(pQueue);
11554 
11555     return cmd_size;
11556 }
11557 
vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)11558 static inline void vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
11559 {
11560     VkCommandTypeEXT command_type;
11561     vn_decode_VkCommandTypeEXT(dec, &command_type);
11562     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue_EXT);
11563 
11564     /* skip device */
11565     /* skip queueFamilyIndex */
11566     /* skip queueIndex */
11567     if (vn_decode_simple_pointer(dec)) {
11568         vn_decode_VkQueue(dec, pQueue);
11569     } else {
11570         pQueue = NULL;
11571     }
11572 }
11573 
vn_sizeof_vkDeviceWaitIdle(VkDevice device)11574 static inline size_t vn_sizeof_vkDeviceWaitIdle(VkDevice device)
11575 {
11576     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
11577     const VkFlags cmd_flags = 0;
11578     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11579 
11580     cmd_size += vn_sizeof_VkDevice(&device);
11581 
11582     return cmd_size;
11583 }
11584 
vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device)11585 static inline void vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device)
11586 {
11587     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
11588 
11589     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11590     vn_encode_VkFlags(enc, &cmd_flags);
11591 
11592     vn_encode_VkDevice(enc, &device);
11593 }
11594 
vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)11595 static inline size_t vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)
11596 {
11597     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
11598     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11599 
11600     VkResult ret;
11601     cmd_size += vn_sizeof_VkResult(&ret);
11602     /* skip device */
11603 
11604     return cmd_size;
11605 }
11606 
vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder * dec,VkDevice device)11607 static inline VkResult vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder *dec, VkDevice device)
11608 {
11609     VkCommandTypeEXT command_type;
11610     vn_decode_VkCommandTypeEXT(dec, &command_type);
11611     assert(command_type == VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT);
11612 
11613     VkResult ret;
11614     vn_decode_VkResult(dec, &ret);
11615     /* skip device */
11616 
11617     return ret;
11618 }
11619 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11620 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11621 {
11622     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
11623     const VkFlags cmd_flags = 0;
11624     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11625 
11626     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11627     cmd_size += vn_sizeof_VkFormat(&format);
11628     cmd_size += vn_sizeof_VkImageType(&type);
11629     cmd_size += vn_sizeof_VkSampleCountFlagBits(&samples);
11630     cmd_size += vn_sizeof_VkFlags(&usage);
11631     cmd_size += vn_sizeof_VkImageTiling(&tiling);
11632     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11633     if (pPropertyCount)
11634         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11635     if (pProperties) {
11636         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11637         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11638             cmd_size += vn_sizeof_VkSparseImageFormatProperties_partial(&pProperties[i]);
11639     } else {
11640         cmd_size += vn_sizeof_array_size(0);
11641     }
11642 
11643     return cmd_size;
11644 }
11645 
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11646 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11647 {
11648     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
11649 
11650     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11651     vn_encode_VkFlags(enc, &cmd_flags);
11652 
11653     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11654     vn_encode_VkFormat(enc, &format);
11655     vn_encode_VkImageType(enc, &type);
11656     vn_encode_VkSampleCountFlagBits(enc, &samples);
11657     vn_encode_VkFlags(enc, &usage);
11658     vn_encode_VkImageTiling(enc, &tiling);
11659     if (vn_encode_simple_pointer(enc, pPropertyCount))
11660         vn_encode_uint32_t(enc, pPropertyCount);
11661     if (pProperties) {
11662         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
11663         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11664             vn_encode_VkSparseImageFormatProperties_partial(enc, &pProperties[i]);
11665     } else {
11666         vn_encode_array_size(enc, 0);
11667     }
11668 }
11669 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11670 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11671 {
11672     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
11673     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11674 
11675     /* skip physicalDevice */
11676     /* skip format */
11677     /* skip type */
11678     /* skip samples */
11679     /* skip usage */
11680     /* skip tiling */
11681     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
11682     if (pPropertyCount)
11683         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
11684     if (pProperties) {
11685         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
11686         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
11687             cmd_size += vn_sizeof_VkSparseImageFormatProperties(&pProperties[i]);
11688     } else {
11689         cmd_size += vn_sizeof_array_size(0);
11690     }
11691 
11692     return cmd_size;
11693 }
11694 
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)11695 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
11696 {
11697     VkCommandTypeEXT command_type;
11698     vn_decode_VkCommandTypeEXT(dec, &command_type);
11699     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT);
11700 
11701     /* skip physicalDevice */
11702     /* skip format */
11703     /* skip type */
11704     /* skip samples */
11705     /* skip usage */
11706     /* skip tiling */
11707     if (vn_decode_simple_pointer(dec)) {
11708         vn_decode_uint32_t(dec, pPropertyCount);
11709     } else {
11710         pPropertyCount = NULL;
11711     }
11712     if (vn_peek_array_size(dec)) {
11713         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
11714         for (uint32_t i = 0; i < iter_count; i++)
11715             vn_decode_VkSparseImageFormatProperties(dec, &pProperties[i]);
11716     } else {
11717         vn_decode_array_size_unchecked(dec);
11718         pProperties = NULL;
11719     }
11720 }
11721 
vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11722 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11723 {
11724     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
11725     const VkFlags cmd_flags = 0;
11726     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11727 
11728     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11729     cmd_size += vn_sizeof_simple_pointer(pFeatures);
11730     if (pFeatures)
11731         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2_partial(pFeatures);
11732 
11733     return cmd_size;
11734 }
11735 
vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11736 static inline void vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11737 {
11738     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
11739 
11740     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11741     vn_encode_VkFlags(enc, &cmd_flags);
11742 
11743     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11744     if (vn_encode_simple_pointer(enc, pFeatures))
11745         vn_encode_VkPhysicalDeviceFeatures2_partial(enc, pFeatures);
11746 }
11747 
vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11748 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11749 {
11750     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
11751     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11752 
11753     /* skip physicalDevice */
11754     cmd_size += vn_sizeof_simple_pointer(pFeatures);
11755     if (pFeatures)
11756         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2(pFeatures);
11757 
11758     return cmd_size;
11759 }
11760 
vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)11761 static inline void vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
11762 {
11763     VkCommandTypeEXT command_type;
11764     vn_decode_VkCommandTypeEXT(dec, &command_type);
11765     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT);
11766 
11767     /* skip physicalDevice */
11768     if (vn_decode_simple_pointer(dec)) {
11769         vn_decode_VkPhysicalDeviceFeatures2(dec, pFeatures);
11770     } else {
11771         pFeatures = NULL;
11772     }
11773 }
11774 
vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11775 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11776 {
11777     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
11778     const VkFlags cmd_flags = 0;
11779     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11780 
11781     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11782     cmd_size += vn_sizeof_simple_pointer(pProperties);
11783     if (pProperties)
11784         cmd_size += vn_sizeof_VkPhysicalDeviceProperties2_partial(pProperties);
11785 
11786     return cmd_size;
11787 }
11788 
vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11789 static inline void vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11790 {
11791     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
11792 
11793     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11794     vn_encode_VkFlags(enc, &cmd_flags);
11795 
11796     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11797     if (vn_encode_simple_pointer(enc, pProperties))
11798         vn_encode_VkPhysicalDeviceProperties2_partial(enc, pProperties);
11799 }
11800 
vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11801 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11802 {
11803     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
11804     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11805 
11806     /* skip physicalDevice */
11807     cmd_size += vn_sizeof_simple_pointer(pProperties);
11808     if (pProperties)
11809         cmd_size += vn_sizeof_VkPhysicalDeviceProperties2(pProperties);
11810 
11811     return cmd_size;
11812 }
11813 
vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)11814 static inline void vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
11815 {
11816     VkCommandTypeEXT command_type;
11817     vn_decode_VkCommandTypeEXT(dec, &command_type);
11818     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT);
11819 
11820     /* skip physicalDevice */
11821     if (vn_decode_simple_pointer(dec)) {
11822         vn_decode_VkPhysicalDeviceProperties2(dec, pProperties);
11823     } else {
11824         pProperties = NULL;
11825     }
11826 }
11827 
vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11828 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11829 {
11830     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
11831     const VkFlags cmd_flags = 0;
11832     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11833 
11834     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11835     cmd_size += vn_sizeof_VkFormat(&format);
11836     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11837     if (pFormatProperties)
11838         cmd_size += vn_sizeof_VkFormatProperties2_partial(pFormatProperties);
11839 
11840     return cmd_size;
11841 }
11842 
vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11843 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11844 {
11845     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
11846 
11847     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11848     vn_encode_VkFlags(enc, &cmd_flags);
11849 
11850     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11851     vn_encode_VkFormat(enc, &format);
11852     if (vn_encode_simple_pointer(enc, pFormatProperties))
11853         vn_encode_VkFormatProperties2_partial(enc, pFormatProperties);
11854 }
11855 
vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11856 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11857 {
11858     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
11859     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11860 
11861     /* skip physicalDevice */
11862     /* skip format */
11863     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
11864     if (pFormatProperties)
11865         cmd_size += vn_sizeof_VkFormatProperties2(pFormatProperties);
11866 
11867     return cmd_size;
11868 }
11869 
vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)11870 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
11871 {
11872     VkCommandTypeEXT command_type;
11873     vn_decode_VkCommandTypeEXT(dec, &command_type);
11874     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT);
11875 
11876     /* skip physicalDevice */
11877     /* skip format */
11878     if (vn_decode_simple_pointer(dec)) {
11879         vn_decode_VkFormatProperties2(dec, pFormatProperties);
11880     } else {
11881         pFormatProperties = NULL;
11882     }
11883 }
11884 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11885 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11886 {
11887     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
11888     const VkFlags cmd_flags = 0;
11889     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11890 
11891     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11892     cmd_size += vn_sizeof_simple_pointer(pImageFormatInfo);
11893     if (pImageFormatInfo)
11894         cmd_size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
11895     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11896     if (pImageFormatProperties)
11897         cmd_size += vn_sizeof_VkImageFormatProperties2_partial(pImageFormatProperties);
11898 
11899     return cmd_size;
11900 }
11901 
vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11902 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11903 {
11904     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
11905 
11906     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11907     vn_encode_VkFlags(enc, &cmd_flags);
11908 
11909     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11910     if (vn_encode_simple_pointer(enc, pImageFormatInfo))
11911         vn_encode_VkPhysicalDeviceImageFormatInfo2(enc, pImageFormatInfo);
11912     if (vn_encode_simple_pointer(enc, pImageFormatProperties))
11913         vn_encode_VkImageFormatProperties2_partial(enc, pImageFormatProperties);
11914 }
11915 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11916 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11917 {
11918     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
11919     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11920 
11921     VkResult ret;
11922     cmd_size += vn_sizeof_VkResult(&ret);
11923     /* skip physicalDevice */
11924     /* skip pImageFormatInfo */
11925     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
11926     if (pImageFormatProperties)
11927         cmd_size += vn_sizeof_VkImageFormatProperties2(pImageFormatProperties);
11928 
11929     return cmd_size;
11930 }
11931 
vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)11932 static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
11933 {
11934     VkCommandTypeEXT command_type;
11935     vn_decode_VkCommandTypeEXT(dec, &command_type);
11936     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT);
11937 
11938     VkResult ret;
11939     vn_decode_VkResult(dec, &ret);
11940     /* skip physicalDevice */
11941     /* skip pImageFormatInfo */
11942     if (vn_decode_simple_pointer(dec)) {
11943         vn_decode_VkImageFormatProperties2(dec, pImageFormatProperties);
11944     } else {
11945         pImageFormatProperties = NULL;
11946     }
11947 
11948     return ret;
11949 }
11950 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)11951 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
11952 {
11953     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
11954     const VkFlags cmd_flags = 0;
11955     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
11956 
11957     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
11958     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
11959     if (pQueueFamilyPropertyCount)
11960         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
11961     if (pQueueFamilyProperties) {
11962         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
11963         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
11964             cmd_size += vn_sizeof_VkQueueFamilyProperties2_partial(&pQueueFamilyProperties[i]);
11965     } else {
11966         cmd_size += vn_sizeof_array_size(0);
11967     }
11968 
11969     return cmd_size;
11970 }
11971 
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)11972 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
11973 {
11974     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
11975 
11976     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
11977     vn_encode_VkFlags(enc, &cmd_flags);
11978 
11979     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
11980     if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
11981         vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
11982     if (pQueueFamilyProperties) {
11983         vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
11984         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
11985             vn_encode_VkQueueFamilyProperties2_partial(enc, &pQueueFamilyProperties[i]);
11986     } else {
11987         vn_encode_array_size(enc, 0);
11988     }
11989 }
11990 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)11991 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
11992 {
11993     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
11994     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
11995 
11996     /* skip physicalDevice */
11997     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
11998     if (pQueueFamilyPropertyCount)
11999         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
12000     if (pQueueFamilyProperties) {
12001         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
12002         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
12003             cmd_size += vn_sizeof_VkQueueFamilyProperties2(&pQueueFamilyProperties[i]);
12004     } else {
12005         cmd_size += vn_sizeof_array_size(0);
12006     }
12007 
12008     return cmd_size;
12009 }
12010 
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)12011 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
12012 {
12013     VkCommandTypeEXT command_type;
12014     vn_decode_VkCommandTypeEXT(dec, &command_type);
12015     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT);
12016 
12017     /* skip physicalDevice */
12018     if (vn_decode_simple_pointer(dec)) {
12019         vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
12020     } else {
12021         pQueueFamilyPropertyCount = NULL;
12022     }
12023     if (vn_peek_array_size(dec)) {
12024         const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
12025         for (uint32_t i = 0; i < iter_count; i++)
12026             vn_decode_VkQueueFamilyProperties2(dec, &pQueueFamilyProperties[i]);
12027     } else {
12028         vn_decode_array_size_unchecked(dec);
12029         pQueueFamilyProperties = NULL;
12030     }
12031 }
12032 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12033 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12034 {
12035     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
12036     const VkFlags cmd_flags = 0;
12037     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12038 
12039     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12040     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
12041     if (pMemoryProperties)
12042         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(pMemoryProperties);
12043 
12044     return cmd_size;
12045 }
12046 
vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12047 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12048 {
12049     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
12050 
12051     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12052     vn_encode_VkFlags(enc, &cmd_flags);
12053 
12054     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12055     if (vn_encode_simple_pointer(enc, pMemoryProperties))
12056         vn_encode_VkPhysicalDeviceMemoryProperties2_partial(enc, pMemoryProperties);
12057 }
12058 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12059 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12060 {
12061     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
12062     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12063 
12064     /* skip physicalDevice */
12065     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
12066     if (pMemoryProperties)
12067         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2(pMemoryProperties);
12068 
12069     return cmd_size;
12070 }
12071 
vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)12072 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
12073 {
12074     VkCommandTypeEXT command_type;
12075     vn_decode_VkCommandTypeEXT(dec, &command_type);
12076     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT);
12077 
12078     /* skip physicalDevice */
12079     if (vn_decode_simple_pointer(dec)) {
12080         vn_decode_VkPhysicalDeviceMemoryProperties2(dec, pMemoryProperties);
12081     } else {
12082         pMemoryProperties = NULL;
12083     }
12084 }
12085 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12086 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12087 {
12088     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
12089     const VkFlags cmd_flags = 0;
12090     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12091 
12092     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12093     cmd_size += vn_sizeof_simple_pointer(pFormatInfo);
12094     if (pFormatInfo)
12095         cmd_size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(pFormatInfo);
12096     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
12097     if (pPropertyCount)
12098         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
12099     if (pProperties) {
12100         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
12101         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
12102             cmd_size += vn_sizeof_VkSparseImageFormatProperties2_partial(&pProperties[i]);
12103     } else {
12104         cmd_size += vn_sizeof_array_size(0);
12105     }
12106 
12107     return cmd_size;
12108 }
12109 
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12110 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12111 {
12112     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
12113 
12114     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12115     vn_encode_VkFlags(enc, &cmd_flags);
12116 
12117     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12118     if (vn_encode_simple_pointer(enc, pFormatInfo))
12119         vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(enc, pFormatInfo);
12120     if (vn_encode_simple_pointer(enc, pPropertyCount))
12121         vn_encode_uint32_t(enc, pPropertyCount);
12122     if (pProperties) {
12123         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
12124         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
12125             vn_encode_VkSparseImageFormatProperties2_partial(enc, &pProperties[i]);
12126     } else {
12127         vn_encode_array_size(enc, 0);
12128     }
12129 }
12130 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12131 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12132 {
12133     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
12134     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12135 
12136     /* skip physicalDevice */
12137     /* skip pFormatInfo */
12138     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
12139     if (pPropertyCount)
12140         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
12141     if (pProperties) {
12142         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
12143         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
12144             cmd_size += vn_sizeof_VkSparseImageFormatProperties2(&pProperties[i]);
12145     } else {
12146         cmd_size += vn_sizeof_array_size(0);
12147     }
12148 
12149     return cmd_size;
12150 }
12151 
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)12152 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
12153 {
12154     VkCommandTypeEXT command_type;
12155     vn_decode_VkCommandTypeEXT(dec, &command_type);
12156     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT);
12157 
12158     /* skip physicalDevice */
12159     /* skip pFormatInfo */
12160     if (vn_decode_simple_pointer(dec)) {
12161         vn_decode_uint32_t(dec, pPropertyCount);
12162     } else {
12163         pPropertyCount = NULL;
12164     }
12165     if (vn_peek_array_size(dec)) {
12166         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
12167         for (uint32_t i = 0; i < iter_count; i++)
12168             vn_decode_VkSparseImageFormatProperties2(dec, &pProperties[i]);
12169     } else {
12170         vn_decode_array_size_unchecked(dec);
12171         pProperties = NULL;
12172     }
12173 }
12174 
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12175 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12176 {
12177     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
12178     const VkFlags cmd_flags = 0;
12179     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12180 
12181     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12182     cmd_size += vn_sizeof_simple_pointer(pExternalBufferInfo);
12183     if (pExternalBufferInfo)
12184         cmd_size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo(pExternalBufferInfo);
12185     cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
12186     if (pExternalBufferProperties)
12187         cmd_size += vn_sizeof_VkExternalBufferProperties_partial(pExternalBufferProperties);
12188 
12189     return cmd_size;
12190 }
12191 
vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12192 static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12193 {
12194     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
12195 
12196     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12197     vn_encode_VkFlags(enc, &cmd_flags);
12198 
12199     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12200     if (vn_encode_simple_pointer(enc, pExternalBufferInfo))
12201         vn_encode_VkPhysicalDeviceExternalBufferInfo(enc, pExternalBufferInfo);
12202     if (vn_encode_simple_pointer(enc, pExternalBufferProperties))
12203         vn_encode_VkExternalBufferProperties_partial(enc, pExternalBufferProperties);
12204 }
12205 
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12206 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12207 {
12208     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
12209     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12210 
12211     /* skip physicalDevice */
12212     /* skip pExternalBufferInfo */
12213     cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
12214     if (pExternalBufferProperties)
12215         cmd_size += vn_sizeof_VkExternalBufferProperties(pExternalBufferProperties);
12216 
12217     return cmd_size;
12218 }
12219 
vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)12220 static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
12221 {
12222     VkCommandTypeEXT command_type;
12223     vn_decode_VkCommandTypeEXT(dec, &command_type);
12224     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT);
12225 
12226     /* skip physicalDevice */
12227     /* skip pExternalBufferInfo */
12228     if (vn_decode_simple_pointer(dec)) {
12229         vn_decode_VkExternalBufferProperties(dec, pExternalBufferProperties);
12230     } else {
12231         pExternalBufferProperties = NULL;
12232     }
12233 }
12234 
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12235 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12236 {
12237     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
12238     const VkFlags cmd_flags = 0;
12239     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12240 
12241     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12242     cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreInfo);
12243     if (pExternalSemaphoreInfo)
12244         cmd_size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(pExternalSemaphoreInfo);
12245     cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
12246     if (pExternalSemaphoreProperties)
12247         cmd_size += vn_sizeof_VkExternalSemaphoreProperties_partial(pExternalSemaphoreProperties);
12248 
12249     return cmd_size;
12250 }
12251 
vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12252 static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12253 {
12254     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
12255 
12256     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12257     vn_encode_VkFlags(enc, &cmd_flags);
12258 
12259     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12260     if (vn_encode_simple_pointer(enc, pExternalSemaphoreInfo))
12261         vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(enc, pExternalSemaphoreInfo);
12262     if (vn_encode_simple_pointer(enc, pExternalSemaphoreProperties))
12263         vn_encode_VkExternalSemaphoreProperties_partial(enc, pExternalSemaphoreProperties);
12264 }
12265 
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12266 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12267 {
12268     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
12269     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12270 
12271     /* skip physicalDevice */
12272     /* skip pExternalSemaphoreInfo */
12273     cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
12274     if (pExternalSemaphoreProperties)
12275         cmd_size += vn_sizeof_VkExternalSemaphoreProperties(pExternalSemaphoreProperties);
12276 
12277     return cmd_size;
12278 }
12279 
vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)12280 static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
12281 {
12282     VkCommandTypeEXT command_type;
12283     vn_decode_VkCommandTypeEXT(dec, &command_type);
12284     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT);
12285 
12286     /* skip physicalDevice */
12287     /* skip pExternalSemaphoreInfo */
12288     if (vn_decode_simple_pointer(dec)) {
12289         vn_decode_VkExternalSemaphoreProperties(dec, pExternalSemaphoreProperties);
12290     } else {
12291         pExternalSemaphoreProperties = NULL;
12292     }
12293 }
12294 
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12295 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12296 {
12297     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
12298     const VkFlags cmd_flags = 0;
12299     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12300 
12301     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
12302     cmd_size += vn_sizeof_simple_pointer(pExternalFenceInfo);
12303     if (pExternalFenceInfo)
12304         cmd_size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo(pExternalFenceInfo);
12305     cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
12306     if (pExternalFenceProperties)
12307         cmd_size += vn_sizeof_VkExternalFenceProperties_partial(pExternalFenceProperties);
12308 
12309     return cmd_size;
12310 }
12311 
vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12312 static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12313 {
12314     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
12315 
12316     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12317     vn_encode_VkFlags(enc, &cmd_flags);
12318 
12319     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
12320     if (vn_encode_simple_pointer(enc, pExternalFenceInfo))
12321         vn_encode_VkPhysicalDeviceExternalFenceInfo(enc, pExternalFenceInfo);
12322     if (vn_encode_simple_pointer(enc, pExternalFenceProperties))
12323         vn_encode_VkExternalFenceProperties_partial(enc, pExternalFenceProperties);
12324 }
12325 
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12326 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12327 {
12328     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
12329     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12330 
12331     /* skip physicalDevice */
12332     /* skip pExternalFenceInfo */
12333     cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
12334     if (pExternalFenceProperties)
12335         cmd_size += vn_sizeof_VkExternalFenceProperties(pExternalFenceProperties);
12336 
12337     return cmd_size;
12338 }
12339 
vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)12340 static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
12341 {
12342     VkCommandTypeEXT command_type;
12343     vn_decode_VkCommandTypeEXT(dec, &command_type);
12344     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT);
12345 
12346     /* skip physicalDevice */
12347     /* skip pExternalFenceInfo */
12348     if (vn_decode_simple_pointer(dec)) {
12349         vn_decode_VkExternalFenceProperties(dec, pExternalFenceProperties);
12350     } else {
12351         pExternalFenceProperties = NULL;
12352     }
12353 }
12354 
vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12355 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12356 {
12357     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
12358     const VkFlags cmd_flags = 0;
12359     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12360 
12361     cmd_size += vn_sizeof_VkInstance(&instance);
12362     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
12363     if (pPhysicalDeviceGroupCount)
12364         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
12365     if (pPhysicalDeviceGroupProperties) {
12366         cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12367         for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
12368             cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties_partial(&pPhysicalDeviceGroupProperties[i]);
12369     } else {
12370         cmd_size += vn_sizeof_array_size(0);
12371     }
12372 
12373     return cmd_size;
12374 }
12375 
vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12376 static inline void vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12377 {
12378     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
12379 
12380     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12381     vn_encode_VkFlags(enc, &cmd_flags);
12382 
12383     vn_encode_VkInstance(enc, &instance);
12384     if (vn_encode_simple_pointer(enc, pPhysicalDeviceGroupCount))
12385         vn_encode_uint32_t(enc, pPhysicalDeviceGroupCount);
12386     if (pPhysicalDeviceGroupProperties) {
12387         vn_encode_array_size(enc, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12388         for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
12389             vn_encode_VkPhysicalDeviceGroupProperties_partial(enc, &pPhysicalDeviceGroupProperties[i]);
12390     } else {
12391         vn_encode_array_size(enc, 0);
12392     }
12393 }
12394 
vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12395 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12396 {
12397     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
12398     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12399 
12400     VkResult ret;
12401     cmd_size += vn_sizeof_VkResult(&ret);
12402     /* skip instance */
12403     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
12404     if (pPhysicalDeviceGroupCount)
12405         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
12406     if (pPhysicalDeviceGroupProperties) {
12407         cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12408         for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
12409             cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties(&pPhysicalDeviceGroupProperties[i]);
12410     } else {
12411         cmd_size += vn_sizeof_array_size(0);
12412     }
12413 
12414     return cmd_size;
12415 }
12416 
vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)12417 static inline VkResult vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
12418 {
12419     VkCommandTypeEXT command_type;
12420     vn_decode_VkCommandTypeEXT(dec, &command_type);
12421     assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT);
12422 
12423     VkResult ret;
12424     vn_decode_VkResult(dec, &ret);
12425     /* skip instance */
12426     if (vn_decode_simple_pointer(dec)) {
12427         vn_decode_uint32_t(dec, pPhysicalDeviceGroupCount);
12428     } else {
12429         pPhysicalDeviceGroupCount = NULL;
12430     }
12431     if (vn_peek_array_size(dec)) {
12432         const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
12433         for (uint32_t i = 0; i < iter_count; i++)
12434             vn_decode_VkPhysicalDeviceGroupProperties(dec, &pPhysicalDeviceGroupProperties[i]);
12435     } else {
12436         vn_decode_array_size_unchecked(dec);
12437         pPhysicalDeviceGroupProperties = NULL;
12438     }
12439 
12440     return ret;
12441 }
12442 
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12443 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12444 {
12445     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
12446     const VkFlags cmd_flags = 0;
12447     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12448 
12449     cmd_size += vn_sizeof_VkDevice(&device);
12450     cmd_size += vn_sizeof_uint32_t(&heapIndex);
12451     cmd_size += vn_sizeof_uint32_t(&localDeviceIndex);
12452     cmd_size += vn_sizeof_uint32_t(&remoteDeviceIndex);
12453     cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); /* out */
12454 
12455     return cmd_size;
12456 }
12457 
vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12458 static inline void vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12459 {
12460     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
12461 
12462     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12463     vn_encode_VkFlags(enc, &cmd_flags);
12464 
12465     vn_encode_VkDevice(enc, &device);
12466     vn_encode_uint32_t(enc, &heapIndex);
12467     vn_encode_uint32_t(enc, &localDeviceIndex);
12468     vn_encode_uint32_t(enc, &remoteDeviceIndex);
12469     vn_encode_simple_pointer(enc, pPeerMemoryFeatures); /* out */
12470 }
12471 
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12472 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12473 {
12474     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
12475     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12476 
12477     /* skip device */
12478     /* skip heapIndex */
12479     /* skip localDeviceIndex */
12480     /* skip remoteDeviceIndex */
12481     cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures);
12482     if (pPeerMemoryFeatures)
12483         cmd_size += vn_sizeof_VkFlags(pPeerMemoryFeatures);
12484 
12485     return cmd_size;
12486 }
12487 
vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)12488 static inline void vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
12489 {
12490     VkCommandTypeEXT command_type;
12491     vn_decode_VkCommandTypeEXT(dec, &command_type);
12492     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT);
12493 
12494     /* skip device */
12495     /* skip heapIndex */
12496     /* skip localDeviceIndex */
12497     /* skip remoteDeviceIndex */
12498     if (vn_decode_simple_pointer(dec)) {
12499         vn_decode_VkFlags(dec, pPeerMemoryFeatures);
12500     } else {
12501         pPeerMemoryFeatures = NULL;
12502     }
12503 }
12504 
vn_sizeof_vkGetDeviceQueue2(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12505 static inline size_t vn_sizeof_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12506 {
12507     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
12508     const VkFlags cmd_flags = 0;
12509     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
12510 
12511     cmd_size += vn_sizeof_VkDevice(&device);
12512     cmd_size += vn_sizeof_simple_pointer(pQueueInfo);
12513     if (pQueueInfo)
12514         cmd_size += vn_sizeof_VkDeviceQueueInfo2(pQueueInfo);
12515     cmd_size += vn_sizeof_simple_pointer(pQueue);
12516     if (pQueue)
12517         cmd_size += vn_sizeof_VkQueue(pQueue);
12518 
12519     return cmd_size;
12520 }
12521 
vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12522 static inline void vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12523 {
12524     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
12525 
12526     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
12527     vn_encode_VkFlags(enc, &cmd_flags);
12528 
12529     vn_encode_VkDevice(enc, &device);
12530     if (vn_encode_simple_pointer(enc, pQueueInfo))
12531         vn_encode_VkDeviceQueueInfo2(enc, pQueueInfo);
12532     if (vn_encode_simple_pointer(enc, pQueue))
12533         vn_encode_VkQueue(enc, pQueue);
12534 }
12535 
vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12536 static inline size_t vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12537 {
12538     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
12539     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
12540 
12541     /* skip device */
12542     /* skip pQueueInfo */
12543     cmd_size += vn_sizeof_simple_pointer(pQueue);
12544     if (pQueue)
12545         cmd_size += vn_sizeof_VkQueue(pQueue);
12546 
12547     return cmd_size;
12548 }
12549 
vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)12550 static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
12551 {
12552     VkCommandTypeEXT command_type;
12553     vn_decode_VkCommandTypeEXT(dec, &command_type);
12554     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT);
12555 
12556     /* skip device */
12557     /* skip pQueueInfo */
12558     if (vn_decode_simple_pointer(dec)) {
12559         vn_decode_VkQueue(dec, pQueue);
12560     } else {
12561         pQueue = NULL;
12562     }
12563 }
12564 
vn_submit_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices,struct vn_instance_submit_command * submit)12565 static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, struct vn_instance_submit_command *submit)
12566 {
12567     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12568     void *cmd_data = local_cmd_data;
12569     size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
12570     if (cmd_size > sizeof(local_cmd_data)) {
12571         cmd_data = malloc(cmd_size);
12572         if (!cmd_data)
12573             cmd_size = 0;
12574     }
12575     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
12576 
12577     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12578     if (cmd_size) {
12579         vn_encode_vkEnumeratePhysicalDevices(enc, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
12580         vn_instance_submit_command(vn_instance, submit);
12581         if (cmd_data != local_cmd_data)
12582             free(cmd_data);
12583     }
12584 }
12585 
vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties,struct vn_instance_submit_command * submit)12586 static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_instance_submit_command *submit)
12587 {
12588     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12589     void *cmd_data = local_cmd_data;
12590     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
12591     if (cmd_size > sizeof(local_cmd_data)) {
12592         cmd_data = malloc(cmd_size);
12593         if (!cmd_data)
12594             cmd_size = 0;
12595     }
12596     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
12597 
12598     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12599     if (cmd_size) {
12600         vn_encode_vkGetPhysicalDeviceProperties(enc, cmd_flags, physicalDevice, pProperties);
12601         vn_instance_submit_command(vn_instance, submit);
12602         if (cmd_data != local_cmd_data)
12603             free(cmd_data);
12604     }
12605 }
12606 
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties,struct vn_instance_submit_command * submit)12607 static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
12608 {
12609     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12610     void *cmd_data = local_cmd_data;
12611     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12612     if (cmd_size > sizeof(local_cmd_data)) {
12613         cmd_data = malloc(cmd_size);
12614         if (!cmd_data)
12615             cmd_size = 0;
12616     }
12617     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
12618 
12619     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12620     if (cmd_size) {
12621         vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12622         vn_instance_submit_command(vn_instance, submit);
12623         if (cmd_data != local_cmd_data)
12624             free(cmd_data);
12625     }
12626 }
12627 
vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties,struct vn_instance_submit_command * submit)12628 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_instance_submit_command *submit)
12629 {
12630     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12631     void *cmd_data = local_cmd_data;
12632     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
12633     if (cmd_size > sizeof(local_cmd_data)) {
12634         cmd_data = malloc(cmd_size);
12635         if (!cmd_data)
12636             cmd_size = 0;
12637     }
12638     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
12639 
12640     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12641     if (cmd_size) {
12642         vn_encode_vkGetPhysicalDeviceMemoryProperties(enc, cmd_flags, physicalDevice, pMemoryProperties);
12643         vn_instance_submit_command(vn_instance, submit);
12644         if (cmd_data != local_cmd_data)
12645             free(cmd_data);
12646     }
12647 }
12648 
vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures,struct vn_instance_submit_command * submit)12649 static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_instance_submit_command *submit)
12650 {
12651     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12652     void *cmd_data = local_cmd_data;
12653     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
12654     if (cmd_size > sizeof(local_cmd_data)) {
12655         cmd_data = malloc(cmd_size);
12656         if (!cmd_data)
12657             cmd_size = 0;
12658     }
12659     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
12660 
12661     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12662     if (cmd_size) {
12663         vn_encode_vkGetPhysicalDeviceFeatures(enc, cmd_flags, physicalDevice, pFeatures);
12664         vn_instance_submit_command(vn_instance, submit);
12665         if (cmd_data != local_cmd_data)
12666             free(cmd_data);
12667     }
12668 }
12669 
vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties,struct vn_instance_submit_command * submit)12670 static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, struct vn_instance_submit_command *submit)
12671 {
12672     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12673     void *cmd_data = local_cmd_data;
12674     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
12675     if (cmd_size > sizeof(local_cmd_data)) {
12676         cmd_data = malloc(cmd_size);
12677         if (!cmd_data)
12678             cmd_size = 0;
12679     }
12680     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
12681 
12682     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12683     if (cmd_size) {
12684         vn_encode_vkGetPhysicalDeviceFormatProperties(enc, cmd_flags, physicalDevice, format, pFormatProperties);
12685         vn_instance_submit_command(vn_instance, submit);
12686         if (cmd_data != local_cmd_data)
12687             free(cmd_data);
12688     }
12689 }
12690 
vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties,struct vn_instance_submit_command * submit)12691 static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, struct vn_instance_submit_command *submit)
12692 {
12693     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12694     void *cmd_data = local_cmd_data;
12695     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
12696     if (cmd_size > sizeof(local_cmd_data)) {
12697         cmd_data = malloc(cmd_size);
12698         if (!cmd_data)
12699             cmd_size = 0;
12700     }
12701     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties) : 0;
12702 
12703     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12704     if (cmd_size) {
12705         vn_encode_vkGetPhysicalDeviceImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
12706         vn_instance_submit_command(vn_instance, submit);
12707         if (cmd_data != local_cmd_data)
12708             free(cmd_data);
12709     }
12710 }
12711 
vn_submit_vkCreateDevice(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice,struct vn_instance_submit_command * submit)12712 static inline void vn_submit_vkCreateDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, struct vn_instance_submit_command *submit)
12713 {
12714     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12715     void *cmd_data = local_cmd_data;
12716     size_t cmd_size = vn_sizeof_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
12717     if (cmd_size > sizeof(local_cmd_data)) {
12718         cmd_data = malloc(cmd_size);
12719         if (!cmd_data)
12720             cmd_size = 0;
12721     }
12722     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
12723 
12724     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12725     if (cmd_size) {
12726         vn_encode_vkCreateDevice(enc, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
12727         vn_instance_submit_command(vn_instance, submit);
12728         if (cmd_data != local_cmd_data)
12729             free(cmd_data);
12730     }
12731 }
12732 
vn_submit_vkDestroyDevice(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator,struct vn_instance_submit_command * submit)12733 static inline void vn_submit_vkDestroyDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
12734 {
12735     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12736     void *cmd_data = local_cmd_data;
12737     size_t cmd_size = vn_sizeof_vkDestroyDevice(device, pAllocator);
12738     if (cmd_size > sizeof(local_cmd_data)) {
12739         cmd_data = malloc(cmd_size);
12740         if (!cmd_data)
12741             cmd_size = 0;
12742     }
12743     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
12744 
12745     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12746     if (cmd_size) {
12747         vn_encode_vkDestroyDevice(enc, cmd_flags, device, pAllocator);
12748         vn_instance_submit_command(vn_instance, submit);
12749         if (cmd_data != local_cmd_data)
12750             free(cmd_data);
12751     }
12752 }
12753 
vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties,struct vn_instance_submit_command * submit)12754 static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
12755 {
12756     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12757     void *cmd_data = local_cmd_data;
12758     size_t cmd_size = vn_sizeof_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
12759     if (cmd_size > sizeof(local_cmd_data)) {
12760         cmd_data = malloc(cmd_size);
12761         if (!cmd_data)
12762             cmd_size = 0;
12763     }
12764     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
12765 
12766     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12767     if (cmd_size) {
12768         vn_encode_vkEnumerateDeviceLayerProperties(enc, cmd_flags, physicalDevice, pPropertyCount, pProperties);
12769         vn_instance_submit_command(vn_instance, submit);
12770         if (cmd_data != local_cmd_data)
12771             free(cmd_data);
12772     }
12773 }
12774 
vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties,struct vn_instance_submit_command * submit)12775 static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
12776 {
12777     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12778     void *cmd_data = local_cmd_data;
12779     size_t cmd_size = vn_sizeof_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
12780     if (cmd_size > sizeof(local_cmd_data)) {
12781         cmd_data = malloc(cmd_size);
12782         if (!cmd_data)
12783             cmd_size = 0;
12784     }
12785     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
12786 
12787     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12788     if (cmd_size) {
12789         vn_encode_vkEnumerateDeviceExtensionProperties(enc, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
12790         vn_instance_submit_command(vn_instance, submit);
12791         if (cmd_data != local_cmd_data)
12792             free(cmd_data);
12793     }
12794 }
12795 
vn_submit_vkGetDeviceQueue(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue,struct vn_instance_submit_command * submit)12796 static inline void vn_submit_vkGetDeviceQueue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, struct vn_instance_submit_command *submit)
12797 {
12798     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12799     void *cmd_data = local_cmd_data;
12800     size_t cmd_size = vn_sizeof_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
12801     if (cmd_size > sizeof(local_cmd_data)) {
12802         cmd_data = malloc(cmd_size);
12803         if (!cmd_data)
12804             cmd_size = 0;
12805     }
12806     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
12807 
12808     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12809     if (cmd_size) {
12810         vn_encode_vkGetDeviceQueue(enc, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
12811         vn_instance_submit_command(vn_instance, submit);
12812         if (cmd_data != local_cmd_data)
12813             free(cmd_data);
12814     }
12815 }
12816 
vn_submit_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,struct vn_instance_submit_command * submit)12817 static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_instance_submit_command *submit)
12818 {
12819     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12820     void *cmd_data = local_cmd_data;
12821     size_t cmd_size = vn_sizeof_vkDeviceWaitIdle(device);
12822     if (cmd_size > sizeof(local_cmd_data)) {
12823         cmd_data = malloc(cmd_size);
12824         if (!cmd_data)
12825             cmd_size = 0;
12826     }
12827     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
12828 
12829     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12830     if (cmd_size) {
12831         vn_encode_vkDeviceWaitIdle(enc, cmd_flags, device);
12832         vn_instance_submit_command(vn_instance, submit);
12833         if (cmd_data != local_cmd_data)
12834             free(cmd_data);
12835     }
12836 }
12837 
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties,struct vn_instance_submit_command * submit)12838 static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, struct vn_instance_submit_command *submit)
12839 {
12840     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12841     void *cmd_data = local_cmd_data;
12842     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
12843     if (cmd_size > sizeof(local_cmd_data)) {
12844         cmd_data = malloc(cmd_size);
12845         if (!cmd_data)
12846             cmd_size = 0;
12847     }
12848     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) : 0;
12849 
12850     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12851     if (cmd_size) {
12852         vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
12853         vn_instance_submit_command(vn_instance, submit);
12854         if (cmd_data != local_cmd_data)
12855             free(cmd_data);
12856     }
12857 }
12858 
vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures,struct vn_instance_submit_command * submit)12859 static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_instance_submit_command *submit)
12860 {
12861     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12862     void *cmd_data = local_cmd_data;
12863     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
12864     if (cmd_size > sizeof(local_cmd_data)) {
12865         cmd_data = malloc(cmd_size);
12866         if (!cmd_data)
12867             cmd_size = 0;
12868     }
12869     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
12870 
12871     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12872     if (cmd_size) {
12873         vn_encode_vkGetPhysicalDeviceFeatures2(enc, cmd_flags, physicalDevice, pFeatures);
12874         vn_instance_submit_command(vn_instance, submit);
12875         if (cmd_data != local_cmd_data)
12876             free(cmd_data);
12877     }
12878 }
12879 
vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties,struct vn_instance_submit_command * submit)12880 static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_instance_submit_command *submit)
12881 {
12882     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12883     void *cmd_data = local_cmd_data;
12884     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
12885     if (cmd_size > sizeof(local_cmd_data)) {
12886         cmd_data = malloc(cmd_size);
12887         if (!cmd_data)
12888             cmd_size = 0;
12889     }
12890     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
12891 
12892     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12893     if (cmd_size) {
12894         vn_encode_vkGetPhysicalDeviceProperties2(enc, cmd_flags, physicalDevice, pProperties);
12895         vn_instance_submit_command(vn_instance, submit);
12896         if (cmd_data != local_cmd_data)
12897             free(cmd_data);
12898     }
12899 }
12900 
vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties,struct vn_instance_submit_command * submit)12901 static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, struct vn_instance_submit_command *submit)
12902 {
12903     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12904     void *cmd_data = local_cmd_data;
12905     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
12906     if (cmd_size > sizeof(local_cmd_data)) {
12907         cmd_data = malloc(cmd_size);
12908         if (!cmd_data)
12909             cmd_size = 0;
12910     }
12911     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
12912 
12913     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12914     if (cmd_size) {
12915         vn_encode_vkGetPhysicalDeviceFormatProperties2(enc, cmd_flags, physicalDevice, format, pFormatProperties);
12916         vn_instance_submit_command(vn_instance, submit);
12917         if (cmd_data != local_cmd_data)
12918             free(cmd_data);
12919     }
12920 }
12921 
vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties,struct vn_instance_submit_command * submit)12922 static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, struct vn_instance_submit_command *submit)
12923 {
12924     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12925     void *cmd_data = local_cmd_data;
12926     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
12927     if (cmd_size > sizeof(local_cmd_data)) {
12928         cmd_data = malloc(cmd_size);
12929         if (!cmd_data)
12930             cmd_size = 0;
12931     }
12932     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
12933 
12934     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12935     if (cmd_size) {
12936         vn_encode_vkGetPhysicalDeviceImageFormatProperties2(enc, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
12937         vn_instance_submit_command(vn_instance, submit);
12938         if (cmd_data != local_cmd_data)
12939             free(cmd_data);
12940     }
12941 }
12942 
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties,struct vn_instance_submit_command * submit)12943 static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
12944 {
12945     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12946     void *cmd_data = local_cmd_data;
12947     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12948     if (cmd_size > sizeof(local_cmd_data)) {
12949         cmd_data = malloc(cmd_size);
12950         if (!cmd_data)
12951             cmd_size = 0;
12952     }
12953     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
12954 
12955     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12956     if (cmd_size) {
12957         vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
12958         vn_instance_submit_command(vn_instance, submit);
12959         if (cmd_data != local_cmd_data)
12960             free(cmd_data);
12961     }
12962 }
12963 
vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties,struct vn_instance_submit_command * submit)12964 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_instance_submit_command *submit)
12965 {
12966     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12967     void *cmd_data = local_cmd_data;
12968     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
12969     if (cmd_size > sizeof(local_cmd_data)) {
12970         cmd_data = malloc(cmd_size);
12971         if (!cmd_data)
12972             cmd_size = 0;
12973     }
12974     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
12975 
12976     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12977     if (cmd_size) {
12978         vn_encode_vkGetPhysicalDeviceMemoryProperties2(enc, cmd_flags, physicalDevice, pMemoryProperties);
12979         vn_instance_submit_command(vn_instance, submit);
12980         if (cmd_data != local_cmd_data)
12981             free(cmd_data);
12982     }
12983 }
12984 
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties,struct vn_instance_submit_command * submit)12985 static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, struct vn_instance_submit_command *submit)
12986 {
12987     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
12988     void *cmd_data = local_cmd_data;
12989     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
12990     if (cmd_size > sizeof(local_cmd_data)) {
12991         cmd_data = malloc(cmd_size);
12992         if (!cmd_data)
12993             cmd_size = 0;
12994     }
12995     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
12996 
12997     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
12998     if (cmd_size) {
12999         vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(enc, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
13000         vn_instance_submit_command(vn_instance, submit);
13001         if (cmd_data != local_cmd_data)
13002             free(cmd_data);
13003     }
13004 }
13005 
vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties,struct vn_instance_submit_command * submit)13006 static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, struct vn_instance_submit_command *submit)
13007 {
13008     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13009     void *cmd_data = local_cmd_data;
13010     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
13011     if (cmd_size > sizeof(local_cmd_data)) {
13012         cmd_data = malloc(cmd_size);
13013         if (!cmd_data)
13014             cmd_size = 0;
13015     }
13016     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
13017 
13018     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13019     if (cmd_size) {
13020         vn_encode_vkGetPhysicalDeviceExternalBufferProperties(enc, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
13021         vn_instance_submit_command(vn_instance, submit);
13022         if (cmd_data != local_cmd_data)
13023             free(cmd_data);
13024     }
13025 }
13026 
vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties,struct vn_instance_submit_command * submit)13027 static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, struct vn_instance_submit_command *submit)
13028 {
13029     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13030     void *cmd_data = local_cmd_data;
13031     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
13032     if (cmd_size > sizeof(local_cmd_data)) {
13033         cmd_data = malloc(cmd_size);
13034         if (!cmd_data)
13035             cmd_size = 0;
13036     }
13037     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
13038 
13039     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13040     if (cmd_size) {
13041         vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(enc, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
13042         vn_instance_submit_command(vn_instance, submit);
13043         if (cmd_data != local_cmd_data)
13044             free(cmd_data);
13045     }
13046 }
13047 
vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties,struct vn_instance_submit_command * submit)13048 static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, struct vn_instance_submit_command *submit)
13049 {
13050     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13051     void *cmd_data = local_cmd_data;
13052     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
13053     if (cmd_size > sizeof(local_cmd_data)) {
13054         cmd_data = malloc(cmd_size);
13055         if (!cmd_data)
13056             cmd_size = 0;
13057     }
13058     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
13059 
13060     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13061     if (cmd_size) {
13062         vn_encode_vkGetPhysicalDeviceExternalFenceProperties(enc, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
13063         vn_instance_submit_command(vn_instance, submit);
13064         if (cmd_data != local_cmd_data)
13065             free(cmd_data);
13066     }
13067 }
13068 
vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,struct vn_instance_submit_command * submit)13069 static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, struct vn_instance_submit_command *submit)
13070 {
13071     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13072     void *cmd_data = local_cmd_data;
13073     size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
13074     if (cmd_size > sizeof(local_cmd_data)) {
13075         cmd_data = malloc(cmd_size);
13076         if (!cmd_data)
13077             cmd_size = 0;
13078     }
13079     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
13080 
13081     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13082     if (cmd_size) {
13083         vn_encode_vkEnumeratePhysicalDeviceGroups(enc, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
13084         vn_instance_submit_command(vn_instance, submit);
13085         if (cmd_data != local_cmd_data)
13086             free(cmd_data);
13087     }
13088 }
13089 
vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures,struct vn_instance_submit_command * submit)13090 static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, struct vn_instance_submit_command *submit)
13091 {
13092     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13093     void *cmd_data = local_cmd_data;
13094     size_t cmd_size = vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
13095     if (cmd_size > sizeof(local_cmd_data)) {
13096         cmd_data = malloc(cmd_size);
13097         if (!cmd_data)
13098             cmd_size = 0;
13099     }
13100     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
13101 
13102     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13103     if (cmd_size) {
13104         vn_encode_vkGetDeviceGroupPeerMemoryFeatures(enc, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
13105         vn_instance_submit_command(vn_instance, submit);
13106         if (cmd_data != local_cmd_data)
13107             free(cmd_data);
13108     }
13109 }
13110 
vn_submit_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue,struct vn_instance_submit_command * submit)13111 static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, struct vn_instance_submit_command *submit)
13112 {
13113     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
13114     void *cmd_data = local_cmd_data;
13115     size_t cmd_size = vn_sizeof_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
13116     if (cmd_size > sizeof(local_cmd_data)) {
13117         cmd_data = malloc(cmd_size);
13118         if (!cmd_data)
13119             cmd_size = 0;
13120     }
13121     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
13122 
13123     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
13124     if (cmd_size) {
13125         vn_encode_vkGetDeviceQueue2(enc, cmd_flags, device, pQueueInfo, pQueue);
13126         vn_instance_submit_command(vn_instance, submit);
13127         if (cmd_data != local_cmd_data)
13128             free(cmd_data);
13129     }
13130 }
13131 
vn_call_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)13132 static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
13133 {
13134     VN_TRACE_FUNC();
13135 
13136     struct vn_instance_submit_command submit;
13137     vn_submit_vkEnumeratePhysicalDevices(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
13138     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13139     if (dec) {
13140         const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(dec, instance, pPhysicalDeviceCount, pPhysicalDevices);
13141         vn_instance_free_command_reply(vn_instance, &submit);
13142         return ret;
13143     } else {
13144         return VK_ERROR_OUT_OF_HOST_MEMORY;
13145     }
13146 }
13147 
vn_async_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)13148 static inline void vn_async_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
13149 {
13150     struct vn_instance_submit_command submit;
13151     vn_submit_vkEnumeratePhysicalDevices(vn_instance, 0, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
13152 }
13153 
vn_call_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)13154 static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
13155 {
13156     VN_TRACE_FUNC();
13157 
13158     struct vn_instance_submit_command submit;
13159     vn_submit_vkGetPhysicalDeviceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
13160     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13161     if (dec) {
13162         vn_decode_vkGetPhysicalDeviceProperties_reply(dec, physicalDevice, pProperties);
13163         vn_instance_free_command_reply(vn_instance, &submit);
13164     }
13165 }
13166 
vn_async_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)13167 static inline void vn_async_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
13168 {
13169     struct vn_instance_submit_command submit;
13170     vn_submit_vkGetPhysicalDeviceProperties(vn_instance, 0, physicalDevice, pProperties, &submit);
13171 }
13172 
vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)13173 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
13174 {
13175     VN_TRACE_FUNC();
13176 
13177     struct vn_instance_submit_command submit;
13178     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13179     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13180     if (dec) {
13181         vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
13182         vn_instance_free_command_reply(vn_instance, &submit);
13183     }
13184 }
13185 
vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)13186 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
13187 {
13188     struct vn_instance_submit_command submit;
13189     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13190 }
13191 
vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)13192 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
13193 {
13194     VN_TRACE_FUNC();
13195 
13196     struct vn_instance_submit_command submit;
13197     vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
13198     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13199     if (dec) {
13200         vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(dec, physicalDevice, pMemoryProperties);
13201         vn_instance_free_command_reply(vn_instance, &submit);
13202     }
13203 }
13204 
vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)13205 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
13206 {
13207     struct vn_instance_submit_command submit;
13208     vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
13209 }
13210 
vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)13211 static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
13212 {
13213     VN_TRACE_FUNC();
13214 
13215     struct vn_instance_submit_command submit;
13216     vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
13217     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13218     if (dec) {
13219         vn_decode_vkGetPhysicalDeviceFeatures_reply(dec, physicalDevice, pFeatures);
13220         vn_instance_free_command_reply(vn_instance, &submit);
13221     }
13222 }
13223 
vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)13224 static inline void vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
13225 {
13226     struct vn_instance_submit_command submit;
13227     vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, 0, physicalDevice, pFeatures, &submit);
13228 }
13229 
vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)13230 static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
13231 {
13232     VN_TRACE_FUNC();
13233 
13234     struct vn_instance_submit_command submit;
13235     vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
13236     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13237     if (dec) {
13238         vn_decode_vkGetPhysicalDeviceFormatProperties_reply(dec, physicalDevice, format, pFormatProperties);
13239         vn_instance_free_command_reply(vn_instance, &submit);
13240     }
13241 }
13242 
vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)13243 static inline void vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
13244 {
13245     struct vn_instance_submit_command submit;
13246     vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
13247 }
13248 
vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)13249 static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
13250 {
13251     VN_TRACE_FUNC();
13252 
13253     struct vn_instance_submit_command submit;
13254     vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
13255     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13256     if (dec) {
13257         const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(dec, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
13258         vn_instance_free_command_reply(vn_instance, &submit);
13259         return ret;
13260     } else {
13261         return VK_ERROR_OUT_OF_HOST_MEMORY;
13262     }
13263 }
13264 
vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)13265 static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
13266 {
13267     struct vn_instance_submit_command submit;
13268     vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, 0, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
13269 }
13270 
vn_call_vkCreateDevice(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)13271 static inline VkResult vn_call_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
13272 {
13273     VN_TRACE_FUNC();
13274 
13275     struct vn_instance_submit_command submit;
13276     vn_submit_vkCreateDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
13277     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13278     if (dec) {
13279         const VkResult ret = vn_decode_vkCreateDevice_reply(dec, physicalDevice, pCreateInfo, pAllocator, pDevice);
13280         vn_instance_free_command_reply(vn_instance, &submit);
13281         return ret;
13282     } else {
13283         return VK_ERROR_OUT_OF_HOST_MEMORY;
13284     }
13285 }
13286 
vn_async_vkCreateDevice(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)13287 static inline void vn_async_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
13288 {
13289     struct vn_instance_submit_command submit;
13290     vn_submit_vkCreateDevice(vn_instance, 0, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
13291 }
13292 
vn_call_vkDestroyDevice(struct vn_instance * vn_instance,VkDevice device,const VkAllocationCallbacks * pAllocator)13293 static inline void vn_call_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
13294 {
13295     VN_TRACE_FUNC();
13296 
13297     struct vn_instance_submit_command submit;
13298     vn_submit_vkDestroyDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit);
13299     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13300     if (dec) {
13301         vn_decode_vkDestroyDevice_reply(dec, device, pAllocator);
13302         vn_instance_free_command_reply(vn_instance, &submit);
13303     }
13304 }
13305 
vn_async_vkDestroyDevice(struct vn_instance * vn_instance,VkDevice device,const VkAllocationCallbacks * pAllocator)13306 static inline void vn_async_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
13307 {
13308     struct vn_instance_submit_command submit;
13309     vn_submit_vkDestroyDevice(vn_instance, 0, device, pAllocator, &submit);
13310 }
13311 
vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)13312 static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
13313 {
13314     VN_TRACE_FUNC();
13315 
13316     struct vn_instance_submit_command submit;
13317     vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit);
13318     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13319     if (dec) {
13320         const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(dec, physicalDevice, pPropertyCount, pProperties);
13321         vn_instance_free_command_reply(vn_instance, &submit);
13322         return ret;
13323     } else {
13324         return VK_ERROR_OUT_OF_HOST_MEMORY;
13325     }
13326 }
13327 
vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)13328 static inline void vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
13329 {
13330     struct vn_instance_submit_command submit;
13331     vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, 0, physicalDevice, pPropertyCount, pProperties, &submit);
13332 }
13333 
vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)13334 static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
13335 {
13336     VN_TRACE_FUNC();
13337 
13338     struct vn_instance_submit_command submit;
13339     vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
13340     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13341     if (dec) {
13342         const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(dec, physicalDevice, pLayerName, pPropertyCount, pProperties);
13343         vn_instance_free_command_reply(vn_instance, &submit);
13344         return ret;
13345     } else {
13346         return VK_ERROR_OUT_OF_HOST_MEMORY;
13347     }
13348 }
13349 
vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)13350 static inline void vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
13351 {
13352     struct vn_instance_submit_command submit;
13353     vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, 0, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
13354 }
13355 
vn_call_vkGetDeviceQueue(struct vn_instance * vn_instance,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)13356 static inline void vn_call_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
13357 {
13358     VN_TRACE_FUNC();
13359 
13360     struct vn_instance_submit_command submit;
13361     vn_submit_vkGetDeviceQueue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit);
13362     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13363     if (dec) {
13364         vn_decode_vkGetDeviceQueue_reply(dec, device, queueFamilyIndex, queueIndex, pQueue);
13365         vn_instance_free_command_reply(vn_instance, &submit);
13366     }
13367 }
13368 
vn_async_vkGetDeviceQueue(struct vn_instance * vn_instance,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)13369 static inline void vn_async_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
13370 {
13371     struct vn_instance_submit_command submit;
13372     vn_submit_vkGetDeviceQueue(vn_instance, 0, device, queueFamilyIndex, queueIndex, pQueue, &submit);
13373 }
13374 
vn_call_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkDevice device)13375 static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
13376 {
13377     VN_TRACE_FUNC();
13378 
13379     struct vn_instance_submit_command submit;
13380     vn_submit_vkDeviceWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit);
13381     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13382     if (dec) {
13383         const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(dec, device);
13384         vn_instance_free_command_reply(vn_instance, &submit);
13385         return ret;
13386     } else {
13387         return VK_ERROR_OUT_OF_HOST_MEMORY;
13388     }
13389 }
13390 
vn_async_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkDevice device)13391 static inline void vn_async_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
13392 {
13393     struct vn_instance_submit_command submit;
13394     vn_submit_vkDeviceWaitIdle(vn_instance, 0, device, &submit);
13395 }
13396 
vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)13397 static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
13398 {
13399     VN_TRACE_FUNC();
13400 
13401     struct vn_instance_submit_command submit;
13402     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
13403     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13404     if (dec) {
13405         vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(dec, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
13406         vn_instance_free_command_reply(vn_instance, &submit);
13407     }
13408 }
13409 
vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)13410 static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
13411 {
13412     struct vn_instance_submit_command submit;
13413     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, 0, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
13414 }
13415 
vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)13416 static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
13417 {
13418     VN_TRACE_FUNC();
13419 
13420     struct vn_instance_submit_command submit;
13421     vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
13422     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13423     if (dec) {
13424         vn_decode_vkGetPhysicalDeviceFeatures2_reply(dec, physicalDevice, pFeatures);
13425         vn_instance_free_command_reply(vn_instance, &submit);
13426     }
13427 }
13428 
vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)13429 static inline void vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
13430 {
13431     struct vn_instance_submit_command submit;
13432     vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, 0, physicalDevice, pFeatures, &submit);
13433 }
13434 
vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)13435 static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
13436 {
13437     VN_TRACE_FUNC();
13438 
13439     struct vn_instance_submit_command submit;
13440     vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
13441     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13442     if (dec) {
13443         vn_decode_vkGetPhysicalDeviceProperties2_reply(dec, physicalDevice, pProperties);
13444         vn_instance_free_command_reply(vn_instance, &submit);
13445     }
13446 }
13447 
vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)13448 static inline void vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
13449 {
13450     struct vn_instance_submit_command submit;
13451     vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, 0, physicalDevice, pProperties, &submit);
13452 }
13453 
vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)13454 static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
13455 {
13456     VN_TRACE_FUNC();
13457 
13458     struct vn_instance_submit_command submit;
13459     vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
13460     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13461     if (dec) {
13462         vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(dec, physicalDevice, format, pFormatProperties);
13463         vn_instance_free_command_reply(vn_instance, &submit);
13464     }
13465 }
13466 
vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)13467 static inline void vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
13468 {
13469     struct vn_instance_submit_command submit;
13470     vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
13471 }
13472 
vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)13473 static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
13474 {
13475     VN_TRACE_FUNC();
13476 
13477     struct vn_instance_submit_command submit;
13478     vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
13479     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13480     if (dec) {
13481         const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(dec, physicalDevice, pImageFormatInfo, pImageFormatProperties);
13482         vn_instance_free_command_reply(vn_instance, &submit);
13483         return ret;
13484     } else {
13485         return VK_ERROR_OUT_OF_HOST_MEMORY;
13486     }
13487 }
13488 
vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)13489 static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
13490 {
13491     struct vn_instance_submit_command submit;
13492     vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, 0, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
13493 }
13494 
vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)13495 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
13496 {
13497     VN_TRACE_FUNC();
13498 
13499     struct vn_instance_submit_command submit;
13500     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13501     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13502     if (dec) {
13503         vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
13504         vn_instance_free_command_reply(vn_instance, &submit);
13505     }
13506 }
13507 
vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)13508 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
13509 {
13510     struct vn_instance_submit_command submit;
13511     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
13512 }
13513 
vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)13514 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
13515 {
13516     VN_TRACE_FUNC();
13517 
13518     struct vn_instance_submit_command submit;
13519     vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
13520     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13521     if (dec) {
13522         vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(dec, physicalDevice, pMemoryProperties);
13523         vn_instance_free_command_reply(vn_instance, &submit);
13524     }
13525 }
13526 
vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)13527 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
13528 {
13529     struct vn_instance_submit_command submit;
13530     vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
13531 }
13532 
vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)13533 static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
13534 {
13535     VN_TRACE_FUNC();
13536 
13537     struct vn_instance_submit_command submit;
13538     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
13539     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13540     if (dec) {
13541         vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(dec, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
13542         vn_instance_free_command_reply(vn_instance, &submit);
13543     }
13544 }
13545 
vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)13546 static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
13547 {
13548     struct vn_instance_submit_command submit;
13549     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, 0, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
13550 }
13551 
vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)13552 static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
13553 {
13554     VN_TRACE_FUNC();
13555 
13556     struct vn_instance_submit_command submit;
13557     vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
13558     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13559     if (dec) {
13560         vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(dec, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
13561         vn_instance_free_command_reply(vn_instance, &submit);
13562     }
13563 }
13564 
vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)13565 static inline void vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
13566 {
13567     struct vn_instance_submit_command submit;
13568     vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, 0, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
13569 }
13570 
vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)13571 static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
13572 {
13573     VN_TRACE_FUNC();
13574 
13575     struct vn_instance_submit_command submit;
13576     vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
13577     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13578     if (dec) {
13579         vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(dec, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
13580         vn_instance_free_command_reply(vn_instance, &submit);
13581     }
13582 }
13583 
vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)13584 static inline void vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
13585 {
13586     struct vn_instance_submit_command submit;
13587     vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, 0, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
13588 }
13589 
vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)13590 static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
13591 {
13592     VN_TRACE_FUNC();
13593 
13594     struct vn_instance_submit_command submit;
13595     vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
13596     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13597     if (dec) {
13598         vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(dec, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
13599         vn_instance_free_command_reply(vn_instance, &submit);
13600     }
13601 }
13602 
vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)13603 static inline void vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
13604 {
13605     struct vn_instance_submit_command submit;
13606     vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, 0, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
13607 }
13608 
vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)13609 static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
13610 {
13611     VN_TRACE_FUNC();
13612 
13613     struct vn_instance_submit_command submit;
13614     vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
13615     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13616     if (dec) {
13617         const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(dec, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
13618         vn_instance_free_command_reply(vn_instance, &submit);
13619         return ret;
13620     } else {
13621         return VK_ERROR_OUT_OF_HOST_MEMORY;
13622     }
13623 }
13624 
vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)13625 static inline void vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
13626 {
13627     struct vn_instance_submit_command submit;
13628     vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, 0, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
13629 }
13630 
vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)13631 static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
13632 {
13633     VN_TRACE_FUNC();
13634 
13635     struct vn_instance_submit_command submit;
13636     vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
13637     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13638     if (dec) {
13639         vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(dec, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
13640         vn_instance_free_command_reply(vn_instance, &submit);
13641     }
13642 }
13643 
vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)13644 static inline void vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
13645 {
13646     struct vn_instance_submit_command submit;
13647     vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, 0, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
13648 }
13649 
vn_call_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)13650 static inline void vn_call_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
13651 {
13652     VN_TRACE_FUNC();
13653 
13654     struct vn_instance_submit_command submit;
13655     vn_submit_vkGetDeviceQueue2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit);
13656     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
13657     if (dec) {
13658         vn_decode_vkGetDeviceQueue2_reply(dec, device, pQueueInfo, pQueue);
13659         vn_instance_free_command_reply(vn_instance, &submit);
13660     }
13661 }
13662 
vn_async_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)13663 static inline void vn_async_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
13664 {
13665     struct vn_instance_submit_command submit;
13666     vn_submit_vkGetDeviceQueue2(vn_instance, 0, device, pQueueInfo, pQueue, &submit);
13667 }
13668 
13669 #endif /* VN_PROTOCOL_DRIVER_DEVICE_H */
13670