• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 VkDevicePrivateDataCreateInfo chain */
1242 
1243 static inline size_t
vn_sizeof_VkDevicePrivateDataCreateInfo_pnext(const void * val)1244 vn_sizeof_VkDevicePrivateDataCreateInfo_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_VkDevicePrivateDataCreateInfo_self(const VkDevicePrivateDataCreateInfo * val)1251 vn_sizeof_VkDevicePrivateDataCreateInfo_self(const VkDevicePrivateDataCreateInfo *val)
1252 {
1253     size_t size = 0;
1254     /* skip val->{sType,pNext} */
1255     size += vn_sizeof_uint32_t(&val->privateDataSlotRequestCount);
1256     return size;
1257 }
1258 
1259 static inline size_t
vn_sizeof_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo * val)1260 vn_sizeof_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo *val)
1261 {
1262     size_t size = 0;
1263 
1264     size += vn_sizeof_VkStructureType(&val->sType);
1265     size += vn_sizeof_VkDevicePrivateDataCreateInfo_pnext(val->pNext);
1266     size += vn_sizeof_VkDevicePrivateDataCreateInfo_self(val);
1267 
1268     return size;
1269 }
1270 
1271 static inline void
vn_encode_VkDevicePrivateDataCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)1272 vn_encode_VkDevicePrivateDataCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
1273 {
1274     /* no known/supported struct */
1275     vn_encode_simple_pointer(enc, NULL);
1276 }
1277 
1278 static inline void
vn_encode_VkDevicePrivateDataCreateInfo_self(struct vn_cs_encoder * enc,const VkDevicePrivateDataCreateInfo * val)1279 vn_encode_VkDevicePrivateDataCreateInfo_self(struct vn_cs_encoder *enc, const VkDevicePrivateDataCreateInfo *val)
1280 {
1281     /* skip val->{sType,pNext} */
1282     vn_encode_uint32_t(enc, &val->privateDataSlotRequestCount);
1283 }
1284 
1285 static inline void
vn_encode_VkDevicePrivateDataCreateInfo(struct vn_cs_encoder * enc,const VkDevicePrivateDataCreateInfo * val)1286 vn_encode_VkDevicePrivateDataCreateInfo(struct vn_cs_encoder *enc, const VkDevicePrivateDataCreateInfo *val)
1287 {
1288     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO);
1289     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO });
1290     vn_encode_VkDevicePrivateDataCreateInfo_pnext(enc, val->pNext);
1291     vn_encode_VkDevicePrivateDataCreateInfo_self(enc, val);
1292 }
1293 
1294 /* struct VkPhysicalDevicePrivateDataFeatures chain */
1295 
1296 static inline size_t
vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext(const void * val)1297 vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext(const void *val)
1298 {
1299     /* no known/supported struct */
1300     return vn_sizeof_simple_pointer(NULL);
1301 }
1302 
1303 static inline size_t
vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self(const VkPhysicalDevicePrivateDataFeatures * val)1304 vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self(const VkPhysicalDevicePrivateDataFeatures *val)
1305 {
1306     size_t size = 0;
1307     /* skip val->{sType,pNext} */
1308     size += vn_sizeof_VkBool32(&val->privateData);
1309     return size;
1310 }
1311 
1312 static inline size_t
vn_sizeof_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures * val)1313 vn_sizeof_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures *val)
1314 {
1315     size_t size = 0;
1316 
1317     size += vn_sizeof_VkStructureType(&val->sType);
1318     size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext(val->pNext);
1319     size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self(val);
1320 
1321     return size;
1322 }
1323 
1324 static inline void
vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1325 vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1326 {
1327     /* no known/supported struct */
1328     vn_encode_simple_pointer(enc, NULL);
1329 }
1330 
1331 static inline void
vn_encode_VkPhysicalDevicePrivateDataFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevicePrivateDataFeatures * val)1332 vn_encode_VkPhysicalDevicePrivateDataFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val)
1333 {
1334     /* skip val->{sType,pNext} */
1335     vn_encode_VkBool32(enc, &val->privateData);
1336 }
1337 
1338 static inline void
vn_encode_VkPhysicalDevicePrivateDataFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevicePrivateDataFeatures * val)1339 vn_encode_VkPhysicalDevicePrivateDataFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val)
1340 {
1341     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
1342     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES });
1343     vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext(enc, val->pNext);
1344     vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, val);
1345 }
1346 
1347 static inline void
vn_decode_VkPhysicalDevicePrivateDataFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1348 vn_decode_VkPhysicalDevicePrivateDataFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1349 {
1350     /* no known/supported struct */
1351     if (vn_decode_simple_pointer(dec))
1352         assert(false);
1353 }
1354 
1355 static inline void
vn_decode_VkPhysicalDevicePrivateDataFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevicePrivateDataFeatures * val)1356 vn_decode_VkPhysicalDevicePrivateDataFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevicePrivateDataFeatures *val)
1357 {
1358     /* skip val->{sType,pNext} */
1359     vn_decode_VkBool32(dec, &val->privateData);
1360 }
1361 
1362 static inline void
vn_decode_VkPhysicalDevicePrivateDataFeatures(struct vn_cs_decoder * dec,VkPhysicalDevicePrivateDataFeatures * val)1363 vn_decode_VkPhysicalDevicePrivateDataFeatures(struct vn_cs_decoder *dec, VkPhysicalDevicePrivateDataFeatures *val)
1364 {
1365     VkStructureType stype;
1366     vn_decode_VkStructureType(dec, &stype);
1367     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
1368 
1369     assert(val->sType == stype);
1370     vn_decode_VkPhysicalDevicePrivateDataFeatures_pnext(dec, val->pNext);
1371     vn_decode_VkPhysicalDevicePrivateDataFeatures_self(dec, val);
1372 }
1373 
1374 static inline size_t
vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext_partial(const void * val)1375 vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext_partial(const void *val)
1376 {
1377     /* no known/supported struct */
1378     return vn_sizeof_simple_pointer(NULL);
1379 }
1380 
1381 static inline size_t
vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial(const VkPhysicalDevicePrivateDataFeatures * val)1382 vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial(const VkPhysicalDevicePrivateDataFeatures *val)
1383 {
1384     size_t size = 0;
1385     /* skip val->{sType,pNext} */
1386     /* skip val->privateData */
1387     return size;
1388 }
1389 
1390 static inline size_t
vn_sizeof_VkPhysicalDevicePrivateDataFeatures_partial(const VkPhysicalDevicePrivateDataFeatures * val)1391 vn_sizeof_VkPhysicalDevicePrivateDataFeatures_partial(const VkPhysicalDevicePrivateDataFeatures *val)
1392 {
1393     size_t size = 0;
1394 
1395     size += vn_sizeof_VkStructureType(&val->sType);
1396     size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_pnext_partial(val->pNext);
1397     size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial(val);
1398 
1399     return size;
1400 }
1401 
1402 static inline void
vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1403 vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1404 {
1405     /* no known/supported struct */
1406     vn_encode_simple_pointer(enc, NULL);
1407 }
1408 
1409 static inline void
vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePrivateDataFeatures * val)1410 vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val)
1411 {
1412     /* skip val->{sType,pNext} */
1413     /* skip val->privateData */
1414 }
1415 
1416 static inline void
vn_encode_VkPhysicalDevicePrivateDataFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePrivateDataFeatures * val)1417 vn_encode_VkPhysicalDevicePrivateDataFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePrivateDataFeatures *val)
1418 {
1419     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
1420     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES });
1421     vn_encode_VkPhysicalDevicePrivateDataFeatures_pnext_partial(enc, val->pNext);
1422     vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(enc, val);
1423 }
1424 
1425 /* struct VkPhysicalDeviceVariablePointersFeatures chain */
1426 
1427 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void * val)1428 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(const void *val)
1429 {
1430     /* no known/supported struct */
1431     return vn_sizeof_simple_pointer(NULL);
1432 }
1433 
1434 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures * val)1435 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(const VkPhysicalDeviceVariablePointersFeatures *val)
1436 {
1437     size_t size = 0;
1438     /* skip val->{sType,pNext} */
1439     size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
1440     size += vn_sizeof_VkBool32(&val->variablePointers);
1441     return size;
1442 }
1443 
1444 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures * val)1445 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures *val)
1446 {
1447     size_t size = 0;
1448 
1449     size += vn_sizeof_VkStructureType(&val->sType);
1450     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext(val->pNext);
1451     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self(val);
1452 
1453     return size;
1454 }
1455 
1456 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1457 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1458 {
1459     /* no known/supported struct */
1460     vn_encode_simple_pointer(enc, NULL);
1461 }
1462 
1463 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1464 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1465 {
1466     /* skip val->{sType,pNext} */
1467     vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
1468     vn_encode_VkBool32(enc, &val->variablePointers);
1469 }
1470 
1471 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1472 vn_encode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1473 {
1474     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1475     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
1476     vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext(enc, val->pNext);
1477     vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, val);
1478 }
1479 
1480 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1481 vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1482 {
1483     /* no known/supported struct */
1484     if (vn_decode_simple_pointer(dec))
1485         assert(false);
1486 }
1487 
1488 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)1489 vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
1490 {
1491     /* skip val->{sType,pNext} */
1492     vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
1493     vn_decode_VkBool32(dec, &val->variablePointers);
1494 }
1495 
1496 static inline void
vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceVariablePointersFeatures * val)1497 vn_decode_VkPhysicalDeviceVariablePointersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVariablePointersFeatures *val)
1498 {
1499     VkStructureType stype;
1500     vn_decode_VkStructureType(dec, &stype);
1501     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1502 
1503     assert(val->sType == stype);
1504     vn_decode_VkPhysicalDeviceVariablePointersFeatures_pnext(dec, val->pNext);
1505     vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, val);
1506 }
1507 
1508 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void * val)1509 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(const void *val)
1510 {
1511     /* no known/supported struct */
1512     return vn_sizeof_simple_pointer(NULL);
1513 }
1514 
1515 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures * val)1516 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
1517 {
1518     size_t size = 0;
1519     /* skip val->{sType,pNext} */
1520     /* skip val->variablePointersStorageBuffer */
1521     /* skip val->variablePointers */
1522     return size;
1523 }
1524 
1525 static inline size_t
vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures * val)1526 vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_partial(const VkPhysicalDeviceVariablePointersFeatures *val)
1527 {
1528     size_t size = 0;
1529 
1530     size += vn_sizeof_VkStructureType(&val->sType);
1531     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(val->pNext);
1532     size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial(val);
1533 
1534     return size;
1535 }
1536 
1537 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1538 vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1539 {
1540     /* no known/supported struct */
1541     vn_encode_simple_pointer(enc, NULL);
1542 }
1543 
1544 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1545 vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1546 {
1547     /* skip val->{sType,pNext} */
1548     /* skip val->variablePointersStorageBuffer */
1549     /* skip val->variablePointers */
1550 }
1551 
1552 static inline void
vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVariablePointersFeatures * val)1553 vn_encode_VkPhysicalDeviceVariablePointersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVariablePointersFeatures *val)
1554 {
1555     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
1556     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES });
1557     vn_encode_VkPhysicalDeviceVariablePointersFeatures_pnext_partial(enc, val->pNext);
1558     vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, val);
1559 }
1560 
1561 /* struct VkPhysicalDeviceMultiviewFeatures chain */
1562 
1563 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void * val)1564 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(const void *val)
1565 {
1566     /* no known/supported struct */
1567     return vn_sizeof_simple_pointer(NULL);
1568 }
1569 
1570 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures * val)1571 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(const VkPhysicalDeviceMultiviewFeatures *val)
1572 {
1573     size_t size = 0;
1574     /* skip val->{sType,pNext} */
1575     size += vn_sizeof_VkBool32(&val->multiview);
1576     size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
1577     size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
1578     return size;
1579 }
1580 
1581 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures * val)1582 vn_sizeof_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures *val)
1583 {
1584     size_t size = 0;
1585 
1586     size += vn_sizeof_VkStructureType(&val->sType);
1587     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext(val->pNext);
1588     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self(val);
1589 
1590     return size;
1591 }
1592 
1593 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1594 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1595 {
1596     /* no known/supported struct */
1597     vn_encode_simple_pointer(enc, NULL);
1598 }
1599 
1600 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1601 vn_encode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1602 {
1603     /* skip val->{sType,pNext} */
1604     vn_encode_VkBool32(enc, &val->multiview);
1605     vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
1606     vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
1607 }
1608 
1609 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1610 vn_encode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1611 {
1612     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1613     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
1614     vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext(enc, val->pNext);
1615     vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, val);
1616 }
1617 
1618 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1619 vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1620 {
1621     /* no known/supported struct */
1622     if (vn_decode_simple_pointer(dec))
1623         assert(false);
1624 }
1625 
1626 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)1627 vn_decode_VkPhysicalDeviceMultiviewFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
1628 {
1629     /* skip val->{sType,pNext} */
1630     vn_decode_VkBool32(dec, &val->multiview);
1631     vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
1632     vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
1633 }
1634 
1635 static inline void
vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewFeatures * val)1636 vn_decode_VkPhysicalDeviceMultiviewFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewFeatures *val)
1637 {
1638     VkStructureType stype;
1639     vn_decode_VkStructureType(dec, &stype);
1640     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1641 
1642     assert(val->sType == stype);
1643     vn_decode_VkPhysicalDeviceMultiviewFeatures_pnext(dec, val->pNext);
1644     vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, val);
1645 }
1646 
1647 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void * val)1648 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(const void *val)
1649 {
1650     /* no known/supported struct */
1651     return vn_sizeof_simple_pointer(NULL);
1652 }
1653 
1654 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures * val)1655 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(const VkPhysicalDeviceMultiviewFeatures *val)
1656 {
1657     size_t size = 0;
1658     /* skip val->{sType,pNext} */
1659     /* skip val->multiview */
1660     /* skip val->multiviewGeometryShader */
1661     /* skip val->multiviewTessellationShader */
1662     return size;
1663 }
1664 
1665 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures * val)1666 vn_sizeof_VkPhysicalDeviceMultiviewFeatures_partial(const VkPhysicalDeviceMultiviewFeatures *val)
1667 {
1668     size_t size = 0;
1669 
1670     size += vn_sizeof_VkStructureType(&val->sType);
1671     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_pnext_partial(val->pNext);
1672     size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial(val);
1673 
1674     return size;
1675 }
1676 
1677 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1678 vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1679 {
1680     /* no known/supported struct */
1681     vn_encode_simple_pointer(enc, NULL);
1682 }
1683 
1684 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1685 vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1686 {
1687     /* skip val->{sType,pNext} */
1688     /* skip val->multiview */
1689     /* skip val->multiviewGeometryShader */
1690     /* skip val->multiviewTessellationShader */
1691 }
1692 
1693 static inline void
vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewFeatures * val)1694 vn_encode_VkPhysicalDeviceMultiviewFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewFeatures *val)
1695 {
1696     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
1697     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES });
1698     vn_encode_VkPhysicalDeviceMultiviewFeatures_pnext_partial(enc, val->pNext);
1699     vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, val);
1700 }
1701 
1702 /* struct VkPhysicalDevice16BitStorageFeatures chain */
1703 
1704 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void * val)1705 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(const void *val)
1706 {
1707     /* no known/supported struct */
1708     return vn_sizeof_simple_pointer(NULL);
1709 }
1710 
1711 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures * val)1712 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(const VkPhysicalDevice16BitStorageFeatures *val)
1713 {
1714     size_t size = 0;
1715     /* skip val->{sType,pNext} */
1716     size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
1717     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
1718     size += vn_sizeof_VkBool32(&val->storagePushConstant16);
1719     size += vn_sizeof_VkBool32(&val->storageInputOutput16);
1720     return size;
1721 }
1722 
1723 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures * val)1724 vn_sizeof_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures *val)
1725 {
1726     size_t size = 0;
1727 
1728     size += vn_sizeof_VkStructureType(&val->sType);
1729     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext(val->pNext);
1730     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self(val);
1731 
1732     return size;
1733 }
1734 
1735 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1736 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1737 {
1738     /* no known/supported struct */
1739     vn_encode_simple_pointer(enc, NULL);
1740 }
1741 
1742 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1743 vn_encode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1744 {
1745     /* skip val->{sType,pNext} */
1746     vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
1747     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
1748     vn_encode_VkBool32(enc, &val->storagePushConstant16);
1749     vn_encode_VkBool32(enc, &val->storageInputOutput16);
1750 }
1751 
1752 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1753 vn_encode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1754 {
1755     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1756     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
1757     vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext(enc, val->pNext);
1758     vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, val);
1759 }
1760 
1761 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1762 vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1763 {
1764     /* no known/supported struct */
1765     if (vn_decode_simple_pointer(dec))
1766         assert(false);
1767 }
1768 
1769 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1770 vn_decode_VkPhysicalDevice16BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1771 {
1772     /* skip val->{sType,pNext} */
1773     vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
1774     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
1775     vn_decode_VkBool32(dec, &val->storagePushConstant16);
1776     vn_decode_VkBool32(dec, &val->storageInputOutput16);
1777 }
1778 
1779 static inline void
vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder * dec,VkPhysicalDevice16BitStorageFeatures * val)1780 vn_decode_VkPhysicalDevice16BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice16BitStorageFeatures *val)
1781 {
1782     VkStructureType stype;
1783     vn_decode_VkStructureType(dec, &stype);
1784     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1785 
1786     assert(val->sType == stype);
1787     vn_decode_VkPhysicalDevice16BitStorageFeatures_pnext(dec, val->pNext);
1788     vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, val);
1789 }
1790 
1791 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void * val)1792 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(const void *val)
1793 {
1794     /* no known/supported struct */
1795     return vn_sizeof_simple_pointer(NULL);
1796 }
1797 
1798 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures * val)1799 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(const VkPhysicalDevice16BitStorageFeatures *val)
1800 {
1801     size_t size = 0;
1802     /* skip val->{sType,pNext} */
1803     /* skip val->storageBuffer16BitAccess */
1804     /* skip val->uniformAndStorageBuffer16BitAccess */
1805     /* skip val->storagePushConstant16 */
1806     /* skip val->storageInputOutput16 */
1807     return size;
1808 }
1809 
1810 static inline size_t
vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures * val)1811 vn_sizeof_VkPhysicalDevice16BitStorageFeatures_partial(const VkPhysicalDevice16BitStorageFeatures *val)
1812 {
1813     size_t size = 0;
1814 
1815     size += vn_sizeof_VkStructureType(&val->sType);
1816     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_pnext_partial(val->pNext);
1817     size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial(val);
1818 
1819     return size;
1820 }
1821 
1822 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1823 vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
1824 {
1825     /* no known/supported struct */
1826     vn_encode_simple_pointer(enc, NULL);
1827 }
1828 
1829 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1830 vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1831 {
1832     /* skip val->{sType,pNext} */
1833     /* skip val->storageBuffer16BitAccess */
1834     /* skip val->uniformAndStorageBuffer16BitAccess */
1835     /* skip val->storagePushConstant16 */
1836     /* skip val->storageInputOutput16 */
1837 }
1838 
1839 static inline void
vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice16BitStorageFeatures * val)1840 vn_encode_VkPhysicalDevice16BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice16BitStorageFeatures *val)
1841 {
1842     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
1843     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES });
1844     vn_encode_VkPhysicalDevice16BitStorageFeatures_pnext_partial(enc, val->pNext);
1845     vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, val);
1846 }
1847 
1848 /* struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures chain */
1849 
1850 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void * val)1851 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(const void *val)
1852 {
1853     /* no known/supported struct */
1854     return vn_sizeof_simple_pointer(NULL);
1855 }
1856 
1857 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1858 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1859 {
1860     size_t size = 0;
1861     /* skip val->{sType,pNext} */
1862     size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
1863     return size;
1864 }
1865 
1866 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1867 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1868 {
1869     size_t size = 0;
1870 
1871     size += vn_sizeof_VkStructureType(&val->sType);
1872     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(val->pNext);
1873     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(val);
1874 
1875     return size;
1876 }
1877 
1878 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder * enc,const void * val)1879 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
1880 {
1881     /* no known/supported struct */
1882     vn_encode_simple_pointer(enc, NULL);
1883 }
1884 
1885 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1886 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1887 {
1888     /* skip val->{sType,pNext} */
1889     vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
1890 }
1891 
1892 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1893 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1894 {
1895     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1896     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
1897     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(enc, val->pNext);
1898     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, val);
1899 }
1900 
1901 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder * dec,const void * val)1902 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
1903 {
1904     /* no known/supported struct */
1905     if (vn_decode_simple_pointer(dec))
1906         assert(false);
1907 }
1908 
1909 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1910 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1911 {
1912     /* skip val->{sType,pNext} */
1913     vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
1914 }
1915 
1916 static inline void
vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1917 vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1918 {
1919     VkStructureType stype;
1920     vn_decode_VkStructureType(dec, &stype);
1921     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1922 
1923     assert(val->sType == stype);
1924     vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext(dec, val->pNext);
1925     vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, val);
1926 }
1927 
1928 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(const void * val)1929 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(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_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1936 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1937 {
1938     size_t size = 0;
1939     /* skip val->{sType,pNext} */
1940     /* skip val->shaderSubgroupExtendedTypes */
1941     return size;
1942 }
1943 
1944 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1945 vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1946 {
1947     size_t size = 0;
1948 
1949     size += vn_sizeof_VkStructureType(&val->sType);
1950     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(val->pNext);
1951     size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(val);
1952 
1953     return size;
1954 }
1955 
1956 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)1957 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(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_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1964 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1965 {
1966     /* skip val->{sType,pNext} */
1967     /* skip val->shaderSubgroupExtendedTypes */
1968 }
1969 
1970 static inline void
vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures * val)1971 vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *val)
1972 {
1973     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
1974     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES });
1975     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_pnext_partial(enc, val->pNext);
1976     vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, val);
1977 }
1978 
1979 /* struct VkPhysicalDeviceSamplerYcbcrConversionFeatures chain */
1980 
1981 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void * val)1982 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(const void *val)
1983 {
1984     /* no known/supported struct */
1985     return vn_sizeof_simple_pointer(NULL);
1986 }
1987 
1988 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1989 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1990 {
1991     size_t size = 0;
1992     /* skip val->{sType,pNext} */
1993     size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
1994     return size;
1995 }
1996 
1997 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)1998 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
1999 {
2000     size_t size = 0;
2001 
2002     size += vn_sizeof_VkStructureType(&val->sType);
2003     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(val->pNext);
2004     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(val);
2005 
2006     return size;
2007 }
2008 
2009 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2010 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2011 {
2012     /* no known/supported struct */
2013     vn_encode_simple_pointer(enc, NULL);
2014 }
2015 
2016 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2017 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2018 {
2019     /* skip val->{sType,pNext} */
2020     vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
2021 }
2022 
2023 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2024 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2025 {
2026     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
2027     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
2028     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(enc, val->pNext);
2029     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, val);
2030 }
2031 
2032 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2033 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2034 {
2035     /* no known/supported struct */
2036     if (vn_decode_simple_pointer(dec))
2037         assert(false);
2038 }
2039 
2040 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2041 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2042 {
2043     /* skip val->{sType,pNext} */
2044     vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
2045 }
2046 
2047 static inline void
vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2048 vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2049 {
2050     VkStructureType stype;
2051     vn_decode_VkStructureType(dec, &stype);
2052     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
2053 
2054     assert(val->sType == stype);
2055     vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext(dec, val->pNext);
2056     vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, val);
2057 }
2058 
2059 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(const void * val)2060 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(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_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2067 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2068 {
2069     size_t size = 0;
2070     /* skip val->{sType,pNext} */
2071     /* skip val->samplerYcbcrConversion */
2072     return size;
2073 }
2074 
2075 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2076 vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2077 {
2078     size_t size = 0;
2079 
2080     size += vn_sizeof_VkStructureType(&val->sType);
2081     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(val->pNext);
2082     size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(val);
2083 
2084     return size;
2085 }
2086 
2087 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2088 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(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_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2095 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2096 {
2097     /* skip val->{sType,pNext} */
2098     /* skip val->samplerYcbcrConversion */
2099 }
2100 
2101 static inline void
vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerYcbcrConversionFeatures * val)2102 vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *val)
2103 {
2104     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
2105     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES });
2106     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_pnext_partial(enc, val->pNext);
2107     vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, val);
2108 }
2109 
2110 /* struct VkPhysicalDeviceProtectedMemoryFeatures chain */
2111 
2112 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void * val)2113 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(const void *val)
2114 {
2115     /* no known/supported struct */
2116     return vn_sizeof_simple_pointer(NULL);
2117 }
2118 
2119 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures * val)2120 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2121 {
2122     size_t size = 0;
2123     /* skip val->{sType,pNext} */
2124     size += vn_sizeof_VkBool32(&val->protectedMemory);
2125     return size;
2126 }
2127 
2128 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures * val)2129 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2130 {
2131     size_t size = 0;
2132 
2133     size += vn_sizeof_VkStructureType(&val->sType);
2134     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext(val->pNext);
2135     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self(val);
2136 
2137     return size;
2138 }
2139 
2140 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2141 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2142 {
2143     /* no known/supported struct */
2144     vn_encode_simple_pointer(enc, NULL);
2145 }
2146 
2147 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2148 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2149 {
2150     /* skip val->{sType,pNext} */
2151     vn_encode_VkBool32(enc, &val->protectedMemory);
2152 }
2153 
2154 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2155 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2156 {
2157     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
2158     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
2159     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(enc, val->pNext);
2160     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, val);
2161 }
2162 
2163 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2164 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2165 {
2166     /* no known/supported struct */
2167     if (vn_decode_simple_pointer(dec))
2168         assert(false);
2169 }
2170 
2171 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)2172 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
2173 {
2174     /* skip val->{sType,pNext} */
2175     vn_decode_VkBool32(dec, &val->protectedMemory);
2176 }
2177 
2178 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryFeatures * val)2179 vn_decode_VkPhysicalDeviceProtectedMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryFeatures *val)
2180 {
2181     VkStructureType stype;
2182     vn_decode_VkStructureType(dec, &stype);
2183     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
2184 
2185     assert(val->sType == stype);
2186     vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_pnext(dec, val->pNext);
2187     vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, val);
2188 }
2189 
2190 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(const void * val)2191 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(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_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures * val)2198 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2199 {
2200     size_t size = 0;
2201     /* skip val->{sType,pNext} */
2202     /* skip val->protectedMemory */
2203     return size;
2204 }
2205 
2206 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures * val)2207 vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_partial(const VkPhysicalDeviceProtectedMemoryFeatures *val)
2208 {
2209     size_t size = 0;
2210 
2211     size += vn_sizeof_VkStructureType(&val->sType);
2212     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(val->pNext);
2213     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(val);
2214 
2215     return size;
2216 }
2217 
2218 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2219 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2220 {
2221     /* no known/supported struct */
2222     vn_encode_simple_pointer(enc, NULL);
2223 }
2224 
2225 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2226 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2227 {
2228     /* skip val->{sType,pNext} */
2229     /* skip val->protectedMemory */
2230 }
2231 
2232 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryFeatures * val)2233 vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryFeatures *val)
2234 {
2235     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
2236     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES });
2237     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_pnext_partial(enc, val->pNext);
2238     vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, val);
2239 }
2240 
2241 /* struct VkPhysicalDeviceInlineUniformBlockFeatures chain */
2242 
2243 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(const void * val)2244 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(const void *val)
2245 {
2246     /* no known/supported struct */
2247     return vn_sizeof_simple_pointer(NULL);
2248 }
2249 
2250 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2251 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2252 {
2253     size_t size = 0;
2254     /* skip val->{sType,pNext} */
2255     size += vn_sizeof_VkBool32(&val->inlineUniformBlock);
2256     size += vn_sizeof_VkBool32(&val->descriptorBindingInlineUniformBlockUpdateAfterBind);
2257     return size;
2258 }
2259 
2260 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2261 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2262 {
2263     size_t size = 0;
2264 
2265     size += vn_sizeof_VkStructureType(&val->sType);
2266     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(val->pNext);
2267     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self(val);
2268 
2269     return size;
2270 }
2271 
2272 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2273 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2274 {
2275     /* no known/supported struct */
2276     vn_encode_simple_pointer(enc, NULL);
2277 }
2278 
2279 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2280 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2281 {
2282     /* skip val->{sType,pNext} */
2283     vn_encode_VkBool32(enc, &val->inlineUniformBlock);
2284     vn_encode_VkBool32(enc, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
2285 }
2286 
2287 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2288 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2289 {
2290     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
2291     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES });
2292     vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(enc, val->pNext);
2293     vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, val);
2294 }
2295 
2296 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2297 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2298 {
2299     /* no known/supported struct */
2300     if (vn_decode_simple_pointer(dec))
2301         assert(false);
2302 }
2303 
2304 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockFeatures * val)2305 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockFeatures *val)
2306 {
2307     /* skip val->{sType,pNext} */
2308     vn_decode_VkBool32(dec, &val->inlineUniformBlock);
2309     vn_decode_VkBool32(dec, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
2310 }
2311 
2312 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockFeatures * val)2313 vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockFeatures *val)
2314 {
2315     VkStructureType stype;
2316     vn_decode_VkStructureType(dec, &stype);
2317     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
2318 
2319     assert(val->sType == stype);
2320     vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext(dec, val->pNext);
2321     vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(dec, val);
2322 }
2323 
2324 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(const void * val)2325 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(const void *val)
2326 {
2327     /* no known/supported struct */
2328     return vn_sizeof_simple_pointer(NULL);
2329 }
2330 
2331 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2332 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2333 {
2334     size_t size = 0;
2335     /* skip val->{sType,pNext} */
2336     /* skip val->inlineUniformBlock */
2337     /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
2338     return size;
2339 }
2340 
2341 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_partial(const VkPhysicalDeviceInlineUniformBlockFeatures * val)2342 vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_partial(const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2343 {
2344     size_t size = 0;
2345 
2346     size += vn_sizeof_VkStructureType(&val->sType);
2347     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(val->pNext);
2348     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(val);
2349 
2350     return size;
2351 }
2352 
2353 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2354 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2355 {
2356     /* no known/supported struct */
2357     vn_encode_simple_pointer(enc, NULL);
2358 }
2359 
2360 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2361 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2362 {
2363     /* skip val->{sType,pNext} */
2364     /* skip val->inlineUniformBlock */
2365     /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
2366 }
2367 
2368 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockFeatures * val)2369 vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockFeatures *val)
2370 {
2371     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
2372     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES });
2373     vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_pnext_partial(enc, val->pNext);
2374     vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(enc, val);
2375 }
2376 
2377 /* struct VkPhysicalDeviceMaintenance4Features chain */
2378 
2379 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext(const void * val)2380 vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext(const void *val)
2381 {
2382     /* no known/supported struct */
2383     return vn_sizeof_simple_pointer(NULL);
2384 }
2385 
2386 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features_self(const VkPhysicalDeviceMaintenance4Features * val)2387 vn_sizeof_VkPhysicalDeviceMaintenance4Features_self(const VkPhysicalDeviceMaintenance4Features *val)
2388 {
2389     size_t size = 0;
2390     /* skip val->{sType,pNext} */
2391     size += vn_sizeof_VkBool32(&val->maintenance4);
2392     return size;
2393 }
2394 
2395 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features * val)2396 vn_sizeof_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features *val)
2397 {
2398     size_t size = 0;
2399 
2400     size += vn_sizeof_VkStructureType(&val->sType);
2401     size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext(val->pNext);
2402     size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self(val);
2403 
2404     return size;
2405 }
2406 
2407 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_encoder * enc,const void * val)2408 vn_encode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_encoder *enc, const void *val)
2409 {
2410     /* no known/supported struct */
2411     vn_encode_simple_pointer(enc, NULL);
2412 }
2413 
2414 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2415 vn_encode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2416 {
2417     /* skip val->{sType,pNext} */
2418     vn_encode_VkBool32(enc, &val->maintenance4);
2419 }
2420 
2421 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2422 vn_encode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2423 {
2424     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
2425     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES });
2426     vn_encode_VkPhysicalDeviceMaintenance4Features_pnext(enc, val->pNext);
2427     vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, val);
2428 }
2429 
2430 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_decoder * dec,const void * val)2431 vn_decode_VkPhysicalDeviceMaintenance4Features_pnext(struct vn_cs_decoder *dec, const void *val)
2432 {
2433     /* no known/supported struct */
2434     if (vn_decode_simple_pointer(dec))
2435         assert(false);
2436 }
2437 
2438 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Features * val)2439 vn_decode_VkPhysicalDeviceMaintenance4Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Features *val)
2440 {
2441     /* skip val->{sType,pNext} */
2442     vn_decode_VkBool32(dec, &val->maintenance4);
2443 }
2444 
2445 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Features * val)2446 vn_decode_VkPhysicalDeviceMaintenance4Features(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Features *val)
2447 {
2448     VkStructureType stype;
2449     vn_decode_VkStructureType(dec, &stype);
2450     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
2451 
2452     assert(val->sType == stype);
2453     vn_decode_VkPhysicalDeviceMaintenance4Features_pnext(dec, val->pNext);
2454     vn_decode_VkPhysicalDeviceMaintenance4Features_self(dec, val);
2455 }
2456 
2457 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext_partial(const void * val)2458 vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext_partial(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_VkPhysicalDeviceMaintenance4Features_self_partial(const VkPhysicalDeviceMaintenance4Features * val)2465 vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial(const VkPhysicalDeviceMaintenance4Features *val)
2466 {
2467     size_t size = 0;
2468     /* skip val->{sType,pNext} */
2469     /* skip val->maintenance4 */
2470     return size;
2471 }
2472 
2473 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Features_partial(const VkPhysicalDeviceMaintenance4Features * val)2474 vn_sizeof_VkPhysicalDeviceMaintenance4Features_partial(const VkPhysicalDeviceMaintenance4Features *val)
2475 {
2476     size_t size = 0;
2477 
2478     size += vn_sizeof_VkStructureType(&val->sType);
2479     size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_pnext_partial(val->pNext);
2480     size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial(val);
2481 
2482     return size;
2483 }
2484 
2485 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)2486 vn_encode_VkPhysicalDeviceMaintenance4Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2487 {
2488     /* no known/supported struct */
2489     vn_encode_simple_pointer(enc, NULL);
2490 }
2491 
2492 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2493 vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2494 {
2495     /* skip val->{sType,pNext} */
2496     /* skip val->maintenance4 */
2497 }
2498 
2499 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Features * val)2500 vn_encode_VkPhysicalDeviceMaintenance4Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Features *val)
2501 {
2502     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
2503     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES });
2504     vn_encode_VkPhysicalDeviceMaintenance4Features_pnext_partial(enc, val->pNext);
2505     vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, val);
2506 }
2507 
2508 /* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
2509 
2510 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void * val)2511 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(const void *val)
2512 {
2513     /* no known/supported struct */
2514     return vn_sizeof_simple_pointer(NULL);
2515 }
2516 
2517 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2518 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2519 {
2520     size_t size = 0;
2521     /* skip val->{sType,pNext} */
2522     size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
2523     return size;
2524 }
2525 
2526 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2527 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2528 {
2529     size_t size = 0;
2530 
2531     size += vn_sizeof_VkStructureType(&val->sType);
2532     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(val->pNext);
2533     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self(val);
2534 
2535     return size;
2536 }
2537 
2538 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2539 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2540 {
2541     /* no known/supported struct */
2542     vn_encode_simple_pointer(enc, NULL);
2543 }
2544 
2545 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2546 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2547 {
2548     /* skip val->{sType,pNext} */
2549     vn_encode_VkBool32(enc, &val->shaderDrawParameters);
2550 }
2551 
2552 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2553 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2554 {
2555     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2556     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2557     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(enc, val->pNext);
2558     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, val);
2559 }
2560 
2561 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2562 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2563 {
2564     /* no known/supported struct */
2565     if (vn_decode_simple_pointer(dec))
2566         assert(false);
2567 }
2568 
2569 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2570 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2571 {
2572     /* skip val->{sType,pNext} */
2573     vn_decode_VkBool32(dec, &val->shaderDrawParameters);
2574 }
2575 
2576 static inline void
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDrawParametersFeatures * val)2577 vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDrawParametersFeatures *val)
2578 {
2579     VkStructureType stype;
2580     vn_decode_VkStructureType(dec, &stype);
2581     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2582 
2583     assert(val->sType == stype);
2584     vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext(dec, val->pNext);
2585     vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, val);
2586 }
2587 
2588 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void * val)2589 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(const void *val)
2590 {
2591     /* no known/supported struct */
2592     return vn_sizeof_simple_pointer(NULL);
2593 }
2594 
2595 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2596 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2597 {
2598     size_t size = 0;
2599     /* skip val->{sType,pNext} */
2600     /* skip val->shaderDrawParameters */
2601     return size;
2602 }
2603 
2604 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures * val)2605 vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_partial(const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2606 {
2607     size_t size = 0;
2608 
2609     size += vn_sizeof_VkStructureType(&val->sType);
2610     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(val->pNext);
2611     size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(val);
2612 
2613     return size;
2614 }
2615 
2616 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2617 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2618 {
2619     /* no known/supported struct */
2620     vn_encode_simple_pointer(enc, NULL);
2621 }
2622 
2623 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2624 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2625 {
2626     /* skip val->{sType,pNext} */
2627     /* skip val->shaderDrawParameters */
2628 }
2629 
2630 static inline void
vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDrawParametersFeatures * val)2631 vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDrawParametersFeatures *val)
2632 {
2633     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
2634     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES });
2635     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_pnext_partial(enc, val->pNext);
2636     vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, val);
2637 }
2638 
2639 /* struct VkPhysicalDeviceShaderFloat16Int8Features chain */
2640 
2641 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void * val)2642 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(const void *val)
2643 {
2644     /* no known/supported struct */
2645     return vn_sizeof_simple_pointer(NULL);
2646 }
2647 
2648 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features * val)2649 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2650 {
2651     size_t size = 0;
2652     /* skip val->{sType,pNext} */
2653     size += vn_sizeof_VkBool32(&val->shaderFloat16);
2654     size += vn_sizeof_VkBool32(&val->shaderInt8);
2655     return size;
2656 }
2657 
2658 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features * val)2659 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2660 {
2661     size_t size = 0;
2662 
2663     size += vn_sizeof_VkStructureType(&val->sType);
2664     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext(val->pNext);
2665     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self(val);
2666 
2667     return size;
2668 }
2669 
2670 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder * enc,const void * val)2671 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_encoder *enc, const void *val)
2672 {
2673     /* no known/supported struct */
2674     vn_encode_simple_pointer(enc, NULL);
2675 }
2676 
2677 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2678 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2679 {
2680     /* skip val->{sType,pNext} */
2681     vn_encode_VkBool32(enc, &val->shaderFloat16);
2682     vn_encode_VkBool32(enc, &val->shaderInt8);
2683 }
2684 
2685 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2686 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2687 {
2688     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2689     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
2690     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(enc, val->pNext);
2691     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, val);
2692 }
2693 
2694 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder * dec,const void * val)2695 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(struct vn_cs_decoder *dec, const void *val)
2696 {
2697     /* no known/supported struct */
2698     if (vn_decode_simple_pointer(dec))
2699         assert(false);
2700 }
2701 
2702 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2703 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2704 {
2705     /* skip val->{sType,pNext} */
2706     vn_decode_VkBool32(dec, &val->shaderFloat16);
2707     vn_decode_VkBool32(dec, &val->shaderInt8);
2708 }
2709 
2710 static inline void
vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderFloat16Int8Features * val)2711 vn_decode_VkPhysicalDeviceShaderFloat16Int8Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderFloat16Int8Features *val)
2712 {
2713     VkStructureType stype;
2714     vn_decode_VkStructureType(dec, &stype);
2715     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2716 
2717     assert(val->sType == stype);
2718     vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_pnext(dec, val->pNext);
2719     vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, val);
2720 }
2721 
2722 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void * val)2723 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(const void *val)
2724 {
2725     /* no known/supported struct */
2726     return vn_sizeof_simple_pointer(NULL);
2727 }
2728 
2729 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)2730 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2731 {
2732     size_t size = 0;
2733     /* skip val->{sType,pNext} */
2734     /* skip val->shaderFloat16 */
2735     /* skip val->shaderInt8 */
2736     return size;
2737 }
2738 
2739 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features * val)2740 vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_partial(const VkPhysicalDeviceShaderFloat16Int8Features *val)
2741 {
2742     size_t size = 0;
2743 
2744     size += vn_sizeof_VkStructureType(&val->sType);
2745     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(val->pNext);
2746     size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(val);
2747 
2748     return size;
2749 }
2750 
2751 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)2752 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2753 {
2754     /* no known/supported struct */
2755     vn_encode_simple_pointer(enc, NULL);
2756 }
2757 
2758 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2759 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2760 {
2761     /* skip val->{sType,pNext} */
2762     /* skip val->shaderFloat16 */
2763     /* skip val->shaderInt8 */
2764 }
2765 
2766 static inline void
vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderFloat16Int8Features * val)2767 vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderFloat16Int8Features *val)
2768 {
2769     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
2770     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES });
2771     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_pnext_partial(enc, val->pNext);
2772     vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, val);
2773 }
2774 
2775 /* struct VkPhysicalDeviceHostQueryResetFeatures chain */
2776 
2777 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void * val)2778 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(const void *val)
2779 {
2780     /* no known/supported struct */
2781     return vn_sizeof_simple_pointer(NULL);
2782 }
2783 
2784 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures * val)2785 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(const VkPhysicalDeviceHostQueryResetFeatures *val)
2786 {
2787     size_t size = 0;
2788     /* skip val->{sType,pNext} */
2789     size += vn_sizeof_VkBool32(&val->hostQueryReset);
2790     return size;
2791 }
2792 
2793 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures * val)2794 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures *val)
2795 {
2796     size_t size = 0;
2797 
2798     size += vn_sizeof_VkStructureType(&val->sType);
2799     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext(val->pNext);
2800     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self(val);
2801 
2802     return size;
2803 }
2804 
2805 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2806 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2807 {
2808     /* no known/supported struct */
2809     vn_encode_simple_pointer(enc, NULL);
2810 }
2811 
2812 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2813 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2814 {
2815     /* skip val->{sType,pNext} */
2816     vn_encode_VkBool32(enc, &val->hostQueryReset);
2817 }
2818 
2819 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2820 vn_encode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2821 {
2822     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2823     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
2824     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext(enc, val->pNext);
2825     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, val);
2826 }
2827 
2828 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2829 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2830 {
2831     /* no known/supported struct */
2832     if (vn_decode_simple_pointer(dec))
2833         assert(false);
2834 }
2835 
2836 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)2837 vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
2838 {
2839     /* skip val->{sType,pNext} */
2840     vn_decode_VkBool32(dec, &val->hostQueryReset);
2841 }
2842 
2843 static inline void
vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceHostQueryResetFeatures * val)2844 vn_decode_VkPhysicalDeviceHostQueryResetFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceHostQueryResetFeatures *val)
2845 {
2846     VkStructureType stype;
2847     vn_decode_VkStructureType(dec, &stype);
2848     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2849 
2850     assert(val->sType == stype);
2851     vn_decode_VkPhysicalDeviceHostQueryResetFeatures_pnext(dec, val->pNext);
2852     vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, val);
2853 }
2854 
2855 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void * val)2856 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(const void *val)
2857 {
2858     /* no known/supported struct */
2859     return vn_sizeof_simple_pointer(NULL);
2860 }
2861 
2862 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)2863 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
2864 {
2865     size_t size = 0;
2866     /* skip val->{sType,pNext} */
2867     /* skip val->hostQueryReset */
2868     return size;
2869 }
2870 
2871 static inline size_t
vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures * val)2872 vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_partial(const VkPhysicalDeviceHostQueryResetFeatures *val)
2873 {
2874     size_t size = 0;
2875 
2876     size += vn_sizeof_VkStructureType(&val->sType);
2877     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(val->pNext);
2878     size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial(val);
2879 
2880     return size;
2881 }
2882 
2883 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)2884 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
2885 {
2886     /* no known/supported struct */
2887     vn_encode_simple_pointer(enc, NULL);
2888 }
2889 
2890 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2891 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2892 {
2893     /* skip val->{sType,pNext} */
2894     /* skip val->hostQueryReset */
2895 }
2896 
2897 static inline void
vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceHostQueryResetFeatures * val)2898 vn_encode_VkPhysicalDeviceHostQueryResetFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceHostQueryResetFeatures *val)
2899 {
2900     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
2901     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES });
2902     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_pnext_partial(enc, val->pNext);
2903     vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, val);
2904 }
2905 
2906 /* struct VkPhysicalDeviceDescriptorIndexingFeatures chain */
2907 
2908 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void * val)2909 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(const void *val)
2910 {
2911     /* no known/supported struct */
2912     return vn_sizeof_simple_pointer(NULL);
2913 }
2914 
2915 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2916 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2917 {
2918     size_t size = 0;
2919     /* skip val->{sType,pNext} */
2920     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
2921     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
2922     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
2923     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
2924     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
2925     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
2926     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
2927     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
2928     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
2929     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
2930     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
2931     size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
2932     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
2933     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
2934     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2935     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2936     size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
2937     size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
2938     size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
2939     size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
2940     return size;
2941 }
2942 
2943 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures * val)2944 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2945 {
2946     size_t size = 0;
2947 
2948     size += vn_sizeof_VkStructureType(&val->sType);
2949     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(val->pNext);
2950     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self(val);
2951 
2952     return size;
2953 }
2954 
2955 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder * enc,const void * val)2956 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
2957 {
2958     /* no known/supported struct */
2959     vn_encode_simple_pointer(enc, NULL);
2960 }
2961 
2962 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2963 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2964 {
2965     /* skip val->{sType,pNext} */
2966     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
2967     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
2968     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
2969     vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
2970     vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
2971     vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
2972     vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
2973     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
2974     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
2975     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
2976     vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
2977     vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
2978     vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
2979     vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
2980     vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
2981     vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
2982     vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
2983     vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
2984     vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
2985     vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
2986 }
2987 
2988 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)2989 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
2990 {
2991     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
2992     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
2993     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(enc, val->pNext);
2994     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, val);
2995 }
2996 
2997 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder * dec,const void * val)2998 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
2999 {
3000     /* no known/supported struct */
3001     if (vn_decode_simple_pointer(dec))
3002         assert(false);
3003 }
3004 
3005 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)3006 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
3007 {
3008     /* skip val->{sType,pNext} */
3009     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
3010     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
3011     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
3012     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
3013     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
3014     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
3015     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
3016     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
3017     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
3018     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
3019     vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
3020     vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
3021     vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
3022     vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
3023     vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
3024     vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
3025     vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
3026     vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
3027     vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
3028     vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
3029 }
3030 
3031 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingFeatures * val)3032 vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingFeatures *val)
3033 {
3034     VkStructureType stype;
3035     vn_decode_VkStructureType(dec, &stype);
3036     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
3037 
3038     assert(val->sType == stype);
3039     vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext(dec, val->pNext);
3040     vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, val);
3041 }
3042 
3043 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void * val)3044 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(const void *val)
3045 {
3046     /* no known/supported struct */
3047     return vn_sizeof_simple_pointer(NULL);
3048 }
3049 
3050 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)3051 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3052 {
3053     size_t size = 0;
3054     /* skip val->{sType,pNext} */
3055     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
3056     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
3057     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
3058     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
3059     /* skip val->shaderSampledImageArrayNonUniformIndexing */
3060     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
3061     /* skip val->shaderStorageImageArrayNonUniformIndexing */
3062     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
3063     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
3064     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
3065     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
3066     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
3067     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
3068     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
3069     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
3070     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
3071     /* skip val->descriptorBindingUpdateUnusedWhilePending */
3072     /* skip val->descriptorBindingPartiallyBound */
3073     /* skip val->descriptorBindingVariableDescriptorCount */
3074     /* skip val->runtimeDescriptorArray */
3075     return size;
3076 }
3077 
3078 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures * val)3079 vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_partial(const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3080 {
3081     size_t size = 0;
3082 
3083     size += vn_sizeof_VkStructureType(&val->sType);
3084     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(val->pNext);
3085     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(val);
3086 
3087     return size;
3088 }
3089 
3090 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3091 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3092 {
3093     /* no known/supported struct */
3094     vn_encode_simple_pointer(enc, NULL);
3095 }
3096 
3097 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)3098 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3099 {
3100     /* skip val->{sType,pNext} */
3101     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
3102     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
3103     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
3104     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
3105     /* skip val->shaderSampledImageArrayNonUniformIndexing */
3106     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
3107     /* skip val->shaderStorageImageArrayNonUniformIndexing */
3108     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
3109     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
3110     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
3111     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
3112     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
3113     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
3114     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
3115     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
3116     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
3117     /* skip val->descriptorBindingUpdateUnusedWhilePending */
3118     /* skip val->descriptorBindingPartiallyBound */
3119     /* skip val->descriptorBindingVariableDescriptorCount */
3120     /* skip val->runtimeDescriptorArray */
3121 }
3122 
3123 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingFeatures * val)3124 vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingFeatures *val)
3125 {
3126     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
3127     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES });
3128     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_pnext_partial(enc, val->pNext);
3129     vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, val);
3130 }
3131 
3132 /* struct VkPhysicalDeviceTimelineSemaphoreFeatures chain */
3133 
3134 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void * val)3135 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(const void *val)
3136 {
3137     /* no known/supported struct */
3138     return vn_sizeof_simple_pointer(NULL);
3139 }
3140 
3141 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3142 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3143 {
3144     size_t size = 0;
3145     /* skip val->{sType,pNext} */
3146     size += vn_sizeof_VkBool32(&val->timelineSemaphore);
3147     return size;
3148 }
3149 
3150 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3151 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3152 {
3153     size_t size = 0;
3154 
3155     size += vn_sizeof_VkStructureType(&val->sType);
3156     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(val->pNext);
3157     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self(val);
3158 
3159     return size;
3160 }
3161 
3162 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3163 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3164 {
3165     /* no known/supported struct */
3166     vn_encode_simple_pointer(enc, NULL);
3167 }
3168 
3169 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3170 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3171 {
3172     /* skip val->{sType,pNext} */
3173     vn_encode_VkBool32(enc, &val->timelineSemaphore);
3174 }
3175 
3176 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3177 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3178 {
3179     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
3180     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
3181     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(enc, val->pNext);
3182     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, val);
3183 }
3184 
3185 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3186 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3187 {
3188     /* no known/supported struct */
3189     if (vn_decode_simple_pointer(dec))
3190         assert(false);
3191 }
3192 
3193 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)3194 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3195 {
3196     /* skip val->{sType,pNext} */
3197     vn_decode_VkBool32(dec, &val->timelineSemaphore);
3198 }
3199 
3200 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreFeatures * val)3201 vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3202 {
3203     VkStructureType stype;
3204     vn_decode_VkStructureType(dec, &stype);
3205     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
3206 
3207     assert(val->sType == stype);
3208     vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext(dec, val->pNext);
3209     vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, val);
3210 }
3211 
3212 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void * val)3213 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(const void *val)
3214 {
3215     /* no known/supported struct */
3216     return vn_sizeof_simple_pointer(NULL);
3217 }
3218 
3219 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3220 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3221 {
3222     size_t size = 0;
3223     /* skip val->{sType,pNext} */
3224     /* skip val->timelineSemaphore */
3225     return size;
3226 }
3227 
3228 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3229 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3230 {
3231     size_t size = 0;
3232 
3233     size += vn_sizeof_VkStructureType(&val->sType);
3234     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(val->pNext);
3235     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(val);
3236 
3237     return size;
3238 }
3239 
3240 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3241 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3242 {
3243     /* no known/supported struct */
3244     vn_encode_simple_pointer(enc, NULL);
3245 }
3246 
3247 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3248 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3249 {
3250     /* skip val->{sType,pNext} */
3251     /* skip val->timelineSemaphore */
3252 }
3253 
3254 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreFeatures * val)3255 vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreFeatures *val)
3256 {
3257     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
3258     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES });
3259     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_pnext_partial(enc, val->pNext);
3260     vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, val);
3261 }
3262 
3263 /* struct VkPhysicalDevice8BitStorageFeatures chain */
3264 
3265 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void * val)3266 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(const void *val)
3267 {
3268     /* no known/supported struct */
3269     return vn_sizeof_simple_pointer(NULL);
3270 }
3271 
3272 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures * val)3273 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(const VkPhysicalDevice8BitStorageFeatures *val)
3274 {
3275     size_t size = 0;
3276     /* skip val->{sType,pNext} */
3277     size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
3278     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
3279     size += vn_sizeof_VkBool32(&val->storagePushConstant8);
3280     return size;
3281 }
3282 
3283 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures * val)3284 vn_sizeof_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures *val)
3285 {
3286     size_t size = 0;
3287 
3288     size += vn_sizeof_VkStructureType(&val->sType);
3289     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext(val->pNext);
3290     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self(val);
3291 
3292     return size;
3293 }
3294 
3295 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3296 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3297 {
3298     /* no known/supported struct */
3299     vn_encode_simple_pointer(enc, NULL);
3300 }
3301 
3302 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3303 vn_encode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3304 {
3305     /* skip val->{sType,pNext} */
3306     vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
3307     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
3308     vn_encode_VkBool32(enc, &val->storagePushConstant8);
3309 }
3310 
3311 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3312 vn_encode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3313 {
3314     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
3315     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
3316     vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext(enc, val->pNext);
3317     vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, val);
3318 }
3319 
3320 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3321 vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3322 {
3323     /* no known/supported struct */
3324     if (vn_decode_simple_pointer(dec))
3325         assert(false);
3326 }
3327 
3328 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)3329 vn_decode_VkPhysicalDevice8BitStorageFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
3330 {
3331     /* skip val->{sType,pNext} */
3332     vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
3333     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
3334     vn_decode_VkBool32(dec, &val->storagePushConstant8);
3335 }
3336 
3337 static inline void
vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder * dec,VkPhysicalDevice8BitStorageFeatures * val)3338 vn_decode_VkPhysicalDevice8BitStorageFeatures(struct vn_cs_decoder *dec, VkPhysicalDevice8BitStorageFeatures *val)
3339 {
3340     VkStructureType stype;
3341     vn_decode_VkStructureType(dec, &stype);
3342     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
3343 
3344     assert(val->sType == stype);
3345     vn_decode_VkPhysicalDevice8BitStorageFeatures_pnext(dec, val->pNext);
3346     vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, val);
3347 }
3348 
3349 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void * val)3350 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(const void *val)
3351 {
3352     /* no known/supported struct */
3353     return vn_sizeof_simple_pointer(NULL);
3354 }
3355 
3356 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures * val)3357 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(const VkPhysicalDevice8BitStorageFeatures *val)
3358 {
3359     size_t size = 0;
3360     /* skip val->{sType,pNext} */
3361     /* skip val->storageBuffer8BitAccess */
3362     /* skip val->uniformAndStorageBuffer8BitAccess */
3363     /* skip val->storagePushConstant8 */
3364     return size;
3365 }
3366 
3367 static inline size_t
vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures * val)3368 vn_sizeof_VkPhysicalDevice8BitStorageFeatures_partial(const VkPhysicalDevice8BitStorageFeatures *val)
3369 {
3370     size_t size = 0;
3371 
3372     size += vn_sizeof_VkStructureType(&val->sType);
3373     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_pnext_partial(val->pNext);
3374     size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial(val);
3375 
3376     return size;
3377 }
3378 
3379 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3380 vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3381 {
3382     /* no known/supported struct */
3383     vn_encode_simple_pointer(enc, NULL);
3384 }
3385 
3386 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3387 vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3388 {
3389     /* skip val->{sType,pNext} */
3390     /* skip val->storageBuffer8BitAccess */
3391     /* skip val->uniformAndStorageBuffer8BitAccess */
3392     /* skip val->storagePushConstant8 */
3393 }
3394 
3395 static inline void
vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice8BitStorageFeatures * val)3396 vn_encode_VkPhysicalDevice8BitStorageFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice8BitStorageFeatures *val)
3397 {
3398     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
3399     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES });
3400     vn_encode_VkPhysicalDevice8BitStorageFeatures_pnext_partial(enc, val->pNext);
3401     vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, val);
3402 }
3403 
3404 /* struct VkPhysicalDeviceConditionalRenderingFeaturesEXT chain */
3405 
3406 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(const void * val)3407 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(const void *val)
3408 {
3409     /* no known/supported struct */
3410     return vn_sizeof_simple_pointer(NULL);
3411 }
3412 
3413 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3414 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3415 {
3416     size_t size = 0;
3417     /* skip val->{sType,pNext} */
3418     size += vn_sizeof_VkBool32(&val->conditionalRendering);
3419     size += vn_sizeof_VkBool32(&val->inheritedConditionalRendering);
3420     return size;
3421 }
3422 
3423 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3424 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3425 {
3426     size_t size = 0;
3427 
3428     size += vn_sizeof_VkStructureType(&val->sType);
3429     size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(val->pNext);
3430     size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(val);
3431 
3432     return size;
3433 }
3434 
3435 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)3436 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
3437 {
3438     /* no known/supported struct */
3439     vn_encode_simple_pointer(enc, NULL);
3440 }
3441 
3442 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3443 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3444 {
3445     /* skip val->{sType,pNext} */
3446     vn_encode_VkBool32(enc, &val->conditionalRendering);
3447     vn_encode_VkBool32(enc, &val->inheritedConditionalRendering);
3448 }
3449 
3450 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3451 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3452 {
3453     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
3454     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT });
3455     vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(enc, val->pNext);
3456     vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(enc, val);
3457 }
3458 
3459 static inline void
vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)3460 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
3461 {
3462     /* no known/supported struct */
3463     if (vn_decode_simple_pointer(dec))
3464         assert(false);
3465 }
3466 
3467 static inline void
vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3468 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3469 {
3470     /* skip val->{sType,pNext} */
3471     vn_decode_VkBool32(dec, &val->conditionalRendering);
3472     vn_decode_VkBool32(dec, &val->inheritedConditionalRendering);
3473 }
3474 
3475 static inline void
vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3476 vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3477 {
3478     VkStructureType stype;
3479     vn_decode_VkStructureType(dec, &stype);
3480     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
3481 
3482     assert(val->sType == stype);
3483     vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext(dec, val->pNext);
3484     vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(dec, val);
3485 }
3486 
3487 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(const void * val)3488 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(const void *val)
3489 {
3490     /* no known/supported struct */
3491     return vn_sizeof_simple_pointer(NULL);
3492 }
3493 
3494 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3495 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3496 {
3497     size_t size = 0;
3498     /* skip val->{sType,pNext} */
3499     /* skip val->conditionalRendering */
3500     /* skip val->inheritedConditionalRendering */
3501     return size;
3502 }
3503 
3504 static inline size_t
vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3505 vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3506 {
3507     size_t size = 0;
3508 
3509     size += vn_sizeof_VkStructureType(&val->sType);
3510     size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(val->pNext);
3511     size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(val);
3512 
3513     return size;
3514 }
3515 
3516 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)3517 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3518 {
3519     /* no known/supported struct */
3520     vn_encode_simple_pointer(enc, NULL);
3521 }
3522 
3523 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3524 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3525 {
3526     /* skip val->{sType,pNext} */
3527     /* skip val->conditionalRendering */
3528     /* skip val->inheritedConditionalRendering */
3529 }
3530 
3531 static inline void
vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConditionalRenderingFeaturesEXT * val)3532 vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *val)
3533 {
3534     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
3535     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT });
3536     vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_pnext_partial(enc, val->pNext);
3537     vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(enc, val);
3538 }
3539 
3540 /* struct VkPhysicalDeviceVulkanMemoryModelFeatures chain */
3541 
3542 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void * val)3543 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(const void *val)
3544 {
3545     /* no known/supported struct */
3546     return vn_sizeof_simple_pointer(NULL);
3547 }
3548 
3549 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3550 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3551 {
3552     size_t size = 0;
3553     /* skip val->{sType,pNext} */
3554     size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
3555     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
3556     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
3557     return size;
3558 }
3559 
3560 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3561 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3562 {
3563     size_t size = 0;
3564 
3565     size += vn_sizeof_VkStructureType(&val->sType);
3566     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(val->pNext);
3567     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self(val);
3568 
3569     return size;
3570 }
3571 
3572 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder * enc,const void * val)3573 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
3574 {
3575     /* no known/supported struct */
3576     vn_encode_simple_pointer(enc, NULL);
3577 }
3578 
3579 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3580 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3581 {
3582     /* skip val->{sType,pNext} */
3583     vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
3584     vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
3585     vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3586 }
3587 
3588 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3589 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3590 {
3591     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3592     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3593     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(enc, val->pNext);
3594     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, val);
3595 }
3596 
3597 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder * dec,const void * val)3598 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
3599 {
3600     /* no known/supported struct */
3601     if (vn_decode_simple_pointer(dec))
3602         assert(false);
3603 }
3604 
3605 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3606 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3607 {
3608     /* skip val->{sType,pNext} */
3609     vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
3610     vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
3611     vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
3612 }
3613 
3614 static inline void
vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkanMemoryModelFeatures * val)3615 vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3616 {
3617     VkStructureType stype;
3618     vn_decode_VkStructureType(dec, &stype);
3619     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3620 
3621     assert(val->sType == stype);
3622     vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext(dec, val->pNext);
3623     vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, val);
3624 }
3625 
3626 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void * val)3627 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(const void *val)
3628 {
3629     /* no known/supported struct */
3630     return vn_sizeof_simple_pointer(NULL);
3631 }
3632 
3633 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3634 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3635 {
3636     size_t size = 0;
3637     /* skip val->{sType,pNext} */
3638     /* skip val->vulkanMemoryModel */
3639     /* skip val->vulkanMemoryModelDeviceScope */
3640     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3641     return size;
3642 }
3643 
3644 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3645 vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3646 {
3647     size_t size = 0;
3648 
3649     size += vn_sizeof_VkStructureType(&val->sType);
3650     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(val->pNext);
3651     size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(val);
3652 
3653     return size;
3654 }
3655 
3656 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)3657 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3658 {
3659     /* no known/supported struct */
3660     vn_encode_simple_pointer(enc, NULL);
3661 }
3662 
3663 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3664 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3665 {
3666     /* skip val->{sType,pNext} */
3667     /* skip val->vulkanMemoryModel */
3668     /* skip val->vulkanMemoryModelDeviceScope */
3669     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
3670 }
3671 
3672 static inline void
vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkanMemoryModelFeatures * val)3673 vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkanMemoryModelFeatures *val)
3674 {
3675     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
3676     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES });
3677     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_pnext_partial(enc, val->pNext);
3678     vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, val);
3679 }
3680 
3681 /* struct VkPhysicalDeviceShaderAtomicInt64Features chain */
3682 
3683 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void * val)3684 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(const void *val)
3685 {
3686     /* no known/supported struct */
3687     return vn_sizeof_simple_pointer(NULL);
3688 }
3689 
3690 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features * val)3691 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3692 {
3693     size_t size = 0;
3694     /* skip val->{sType,pNext} */
3695     size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
3696     size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
3697     return size;
3698 }
3699 
3700 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features * val)3701 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3702 {
3703     size_t size = 0;
3704 
3705     size += vn_sizeof_VkStructureType(&val->sType);
3706     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext(val->pNext);
3707     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self(val);
3708 
3709     return size;
3710 }
3711 
3712 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder * enc,const void * val)3713 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_encoder *enc, const void *val)
3714 {
3715     /* no known/supported struct */
3716     vn_encode_simple_pointer(enc, NULL);
3717 }
3718 
3719 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3720 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3721 {
3722     /* skip val->{sType,pNext} */
3723     vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
3724     vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
3725 }
3726 
3727 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3728 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3729 {
3730     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3731     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
3732     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(enc, val->pNext);
3733     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, val);
3734 }
3735 
3736 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder * dec,const void * val)3737 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(struct vn_cs_decoder *dec, const void *val)
3738 {
3739     /* no known/supported struct */
3740     if (vn_decode_simple_pointer(dec))
3741         assert(false);
3742 }
3743 
3744 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)3745 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
3746 {
3747     /* skip val->{sType,pNext} */
3748     vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
3749     vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
3750 }
3751 
3752 static inline void
vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderAtomicInt64Features * val)3753 vn_decode_VkPhysicalDeviceShaderAtomicInt64Features(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderAtomicInt64Features *val)
3754 {
3755     VkStructureType stype;
3756     vn_decode_VkStructureType(dec, &stype);
3757     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3758 
3759     assert(val->sType == stype);
3760     vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_pnext(dec, val->pNext);
3761     vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, val);
3762 }
3763 
3764 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void * val)3765 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(const void *val)
3766 {
3767     /* no known/supported struct */
3768     return vn_sizeof_simple_pointer(NULL);
3769 }
3770 
3771 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)3772 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3773 {
3774     size_t size = 0;
3775     /* skip val->{sType,pNext} */
3776     /* skip val->shaderBufferInt64Atomics */
3777     /* skip val->shaderSharedInt64Atomics */
3778     return size;
3779 }
3780 
3781 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features * val)3782 vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_partial(const VkPhysicalDeviceShaderAtomicInt64Features *val)
3783 {
3784     size_t size = 0;
3785 
3786     size += vn_sizeof_VkStructureType(&val->sType);
3787     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(val->pNext);
3788     size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(val);
3789 
3790     return size;
3791 }
3792 
3793 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)3794 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3795 {
3796     /* no known/supported struct */
3797     vn_encode_simple_pointer(enc, NULL);
3798 }
3799 
3800 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3801 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3802 {
3803     /* skip val->{sType,pNext} */
3804     /* skip val->shaderBufferInt64Atomics */
3805     /* skip val->shaderSharedInt64Atomics */
3806 }
3807 
3808 static inline void
vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderAtomicInt64Features * val)3809 vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderAtomicInt64Features *val)
3810 {
3811     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
3812     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES });
3813     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_pnext_partial(enc, val->pNext);
3814     vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, val);
3815 }
3816 
3817 /* struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT chain */
3818 
3819 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(const void * val)3820 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(const void *val)
3821 {
3822     /* no known/supported struct */
3823     return vn_sizeof_simple_pointer(NULL);
3824 }
3825 
3826 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3827 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3828 {
3829     size_t size = 0;
3830     /* skip val->{sType,pNext} */
3831     size += vn_sizeof_VkBool32(&val->vertexAttributeInstanceRateDivisor);
3832     size += vn_sizeof_VkBool32(&val->vertexAttributeInstanceRateZeroDivisor);
3833     return size;
3834 }
3835 
3836 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3837 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3838 {
3839     size_t size = 0;
3840 
3841     size += vn_sizeof_VkStructureType(&val->sType);
3842     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(val->pNext);
3843     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(val);
3844 
3845     return size;
3846 }
3847 
3848 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)3849 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
3850 {
3851     /* no known/supported struct */
3852     vn_encode_simple_pointer(enc, NULL);
3853 }
3854 
3855 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3856 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3857 {
3858     /* skip val->{sType,pNext} */
3859     vn_encode_VkBool32(enc, &val->vertexAttributeInstanceRateDivisor);
3860     vn_encode_VkBool32(enc, &val->vertexAttributeInstanceRateZeroDivisor);
3861 }
3862 
3863 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3864 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3865 {
3866     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
3867     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT });
3868     vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(enc, val->pNext);
3869     vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(enc, val);
3870 }
3871 
3872 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)3873 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
3874 {
3875     /* no known/supported struct */
3876     if (vn_decode_simple_pointer(dec))
3877         assert(false);
3878 }
3879 
3880 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3881 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3882 {
3883     /* skip val->{sType,pNext} */
3884     vn_decode_VkBool32(dec, &val->vertexAttributeInstanceRateDivisor);
3885     vn_decode_VkBool32(dec, &val->vertexAttributeInstanceRateZeroDivisor);
3886 }
3887 
3888 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3889 vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3890 {
3891     VkStructureType stype;
3892     vn_decode_VkStructureType(dec, &stype);
3893     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
3894 
3895     assert(val->sType == stype);
3896     vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext(dec, val->pNext);
3897     vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(dec, val);
3898 }
3899 
3900 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(const void * val)3901 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(const void *val)
3902 {
3903     /* no known/supported struct */
3904     return vn_sizeof_simple_pointer(NULL);
3905 }
3906 
3907 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3908 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3909 {
3910     size_t size = 0;
3911     /* skip val->{sType,pNext} */
3912     /* skip val->vertexAttributeInstanceRateDivisor */
3913     /* skip val->vertexAttributeInstanceRateZeroDivisor */
3914     return size;
3915 }
3916 
3917 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3918 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3919 {
3920     size_t size = 0;
3921 
3922     size += vn_sizeof_VkStructureType(&val->sType);
3923     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(val->pNext);
3924     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(val);
3925 
3926     return size;
3927 }
3928 
3929 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)3930 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
3931 {
3932     /* no known/supported struct */
3933     vn_encode_simple_pointer(enc, NULL);
3934 }
3935 
3936 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3937 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3938 {
3939     /* skip val->{sType,pNext} */
3940     /* skip val->vertexAttributeInstanceRateDivisor */
3941     /* skip val->vertexAttributeInstanceRateZeroDivisor */
3942 }
3943 
3944 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT * val)3945 vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *val)
3946 {
3947     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
3948     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT });
3949     vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_pnext_partial(enc, val->pNext);
3950     vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(enc, val);
3951 }
3952 
3953 /* struct VkPhysicalDeviceTransformFeedbackFeaturesEXT chain */
3954 
3955 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void * val)3956 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(const void *val)
3957 {
3958     /* no known/supported struct */
3959     return vn_sizeof_simple_pointer(NULL);
3960 }
3961 
3962 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3963 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3964 {
3965     size_t size = 0;
3966     /* skip val->{sType,pNext} */
3967     size += vn_sizeof_VkBool32(&val->transformFeedback);
3968     size += vn_sizeof_VkBool32(&val->geometryStreams);
3969     return size;
3970 }
3971 
3972 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3973 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3974 {
3975     size_t size = 0;
3976 
3977     size += vn_sizeof_VkStructureType(&val->sType);
3978     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(val->pNext);
3979     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(val);
3980 
3981     return size;
3982 }
3983 
3984 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)3985 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
3986 {
3987     /* no known/supported struct */
3988     vn_encode_simple_pointer(enc, NULL);
3989 }
3990 
3991 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)3992 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
3993 {
3994     /* skip val->{sType,pNext} */
3995     vn_encode_VkBool32(enc, &val->transformFeedback);
3996     vn_encode_VkBool32(enc, &val->geometryStreams);
3997 }
3998 
3999 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4000 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4001 {
4002     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
4003     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
4004     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(enc, val->pNext);
4005     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, val);
4006 }
4007 
4008 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)4009 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
4010 {
4011     /* no known/supported struct */
4012     if (vn_decode_simple_pointer(dec))
4013         assert(false);
4014 }
4015 
4016 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4017 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4018 {
4019     /* skip val->{sType,pNext} */
4020     vn_decode_VkBool32(dec, &val->transformFeedback);
4021     vn_decode_VkBool32(dec, &val->geometryStreams);
4022 }
4023 
4024 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4025 vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4026 {
4027     VkStructureType stype;
4028     vn_decode_VkStructureType(dec, &stype);
4029     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
4030 
4031     assert(val->sType == stype);
4032     vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext(dec, val->pNext);
4033     vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, val);
4034 }
4035 
4036 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void * val)4037 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(const void *val)
4038 {
4039     /* no known/supported struct */
4040     return vn_sizeof_simple_pointer(NULL);
4041 }
4042 
4043 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4044 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4045 {
4046     size_t size = 0;
4047     /* skip val->{sType,pNext} */
4048     /* skip val->transformFeedback */
4049     /* skip val->geometryStreams */
4050     return size;
4051 }
4052 
4053 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4054 vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4055 {
4056     size_t size = 0;
4057 
4058     size += vn_sizeof_VkStructureType(&val->sType);
4059     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(val->pNext);
4060     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(val);
4061 
4062     return size;
4063 }
4064 
4065 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)4066 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4067 {
4068     /* no known/supported struct */
4069     vn_encode_simple_pointer(enc, NULL);
4070 }
4071 
4072 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4073 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4074 {
4075     /* skip val->{sType,pNext} */
4076     /* skip val->transformFeedback */
4077     /* skip val->geometryStreams */
4078 }
4079 
4080 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackFeaturesEXT * val)4081 vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *val)
4082 {
4083     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
4084     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT });
4085     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_pnext_partial(enc, val->pNext);
4086     vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, val);
4087 }
4088 
4089 /* struct VkPhysicalDeviceScalarBlockLayoutFeatures chain */
4090 
4091 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void * val)4092 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(const void *val)
4093 {
4094     /* no known/supported struct */
4095     return vn_sizeof_simple_pointer(NULL);
4096 }
4097 
4098 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4099 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4100 {
4101     size_t size = 0;
4102     /* skip val->{sType,pNext} */
4103     size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
4104     return size;
4105 }
4106 
4107 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4108 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4109 {
4110     size_t size = 0;
4111 
4112     size += vn_sizeof_VkStructureType(&val->sType);
4113     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(val->pNext);
4114     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self(val);
4115 
4116     return size;
4117 }
4118 
4119 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4120 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
4121 {
4122     /* no known/supported struct */
4123     vn_encode_simple_pointer(enc, NULL);
4124 }
4125 
4126 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4127 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4128 {
4129     /* skip val->{sType,pNext} */
4130     vn_encode_VkBool32(enc, &val->scalarBlockLayout);
4131 }
4132 
4133 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4134 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4135 {
4136     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
4137     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
4138     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(enc, val->pNext);
4139     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, val);
4140 }
4141 
4142 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4143 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
4144 {
4145     /* no known/supported struct */
4146     if (vn_decode_simple_pointer(dec))
4147         assert(false);
4148 }
4149 
4150 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)4151 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4152 {
4153     /* skip val->{sType,pNext} */
4154     vn_decode_VkBool32(dec, &val->scalarBlockLayout);
4155 }
4156 
4157 static inline void
vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceScalarBlockLayoutFeatures * val)4158 vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4159 {
4160     VkStructureType stype;
4161     vn_decode_VkStructureType(dec, &stype);
4162     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
4163 
4164     assert(val->sType == stype);
4165     vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext(dec, val->pNext);
4166     vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, val);
4167 }
4168 
4169 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void * val)4170 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(const void *val)
4171 {
4172     /* no known/supported struct */
4173     return vn_sizeof_simple_pointer(NULL);
4174 }
4175 
4176 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4177 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4178 {
4179     size_t size = 0;
4180     /* skip val->{sType,pNext} */
4181     /* skip val->scalarBlockLayout */
4182     return size;
4183 }
4184 
4185 static inline size_t
vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4186 vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4187 {
4188     size_t size = 0;
4189 
4190     size += vn_sizeof_VkStructureType(&val->sType);
4191     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(val->pNext);
4192     size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(val);
4193 
4194     return size;
4195 }
4196 
4197 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4198 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4199 {
4200     /* no known/supported struct */
4201     vn_encode_simple_pointer(enc, NULL);
4202 }
4203 
4204 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4205 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4206 {
4207     /* skip val->{sType,pNext} */
4208     /* skip val->scalarBlockLayout */
4209 }
4210 
4211 static inline void
vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceScalarBlockLayoutFeatures * val)4212 vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceScalarBlockLayoutFeatures *val)
4213 {
4214     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
4215     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES });
4216     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_pnext_partial(enc, val->pNext);
4217     vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, val);
4218 }
4219 
4220 /* struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures chain */
4221 
4222 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void * val)4223 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(const void *val)
4224 {
4225     /* no known/supported struct */
4226     return vn_sizeof_simple_pointer(NULL);
4227 }
4228 
4229 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4230 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4231 {
4232     size_t size = 0;
4233     /* skip val->{sType,pNext} */
4234     size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
4235     return size;
4236 }
4237 
4238 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4239 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4240 {
4241     size_t size = 0;
4242 
4243     size += vn_sizeof_VkStructureType(&val->sType);
4244     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(val->pNext);
4245     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(val);
4246 
4247     return size;
4248 }
4249 
4250 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4251 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
4252 {
4253     /* no known/supported struct */
4254     vn_encode_simple_pointer(enc, NULL);
4255 }
4256 
4257 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4258 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4259 {
4260     /* skip val->{sType,pNext} */
4261     vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
4262 }
4263 
4264 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4265 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4266 {
4267     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
4268     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
4269     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(enc, val->pNext);
4270     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, val);
4271 }
4272 
4273 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4274 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
4275 {
4276     /* no known/supported struct */
4277     if (vn_decode_simple_pointer(dec))
4278         assert(false);
4279 }
4280 
4281 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4282 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4283 {
4284     /* skip val->{sType,pNext} */
4285     vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
4286 }
4287 
4288 static inline void
vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4289 vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4290 {
4291     VkStructureType stype;
4292     vn_decode_VkStructureType(dec, &stype);
4293     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
4294 
4295     assert(val->sType == stype);
4296     vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext(dec, val->pNext);
4297     vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, val);
4298 }
4299 
4300 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void * val)4301 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(const void *val)
4302 {
4303     /* no known/supported struct */
4304     return vn_sizeof_simple_pointer(NULL);
4305 }
4306 
4307 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4308 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4309 {
4310     size_t size = 0;
4311     /* skip val->{sType,pNext} */
4312     /* skip val->uniformBufferStandardLayout */
4313     return size;
4314 }
4315 
4316 static inline size_t
vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4317 vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4318 {
4319     size_t size = 0;
4320 
4321     size += vn_sizeof_VkStructureType(&val->sType);
4322     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(val->pNext);
4323     size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(val);
4324 
4325     return size;
4326 }
4327 
4328 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4329 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4330 {
4331     /* no known/supported struct */
4332     vn_encode_simple_pointer(enc, NULL);
4333 }
4334 
4335 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4336 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4337 {
4338     /* skip val->{sType,pNext} */
4339     /* skip val->uniformBufferStandardLayout */
4340 }
4341 
4342 static inline void
vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceUniformBufferStandardLayoutFeatures * val)4343 vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *val)
4344 {
4345     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
4346     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES });
4347     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_pnext_partial(enc, val->pNext);
4348     vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, val);
4349 }
4350 
4351 /* struct VkPhysicalDeviceDepthClipEnableFeaturesEXT chain */
4352 
4353 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(const void * val)4354 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(const void *val)
4355 {
4356     /* no known/supported struct */
4357     return vn_sizeof_simple_pointer(NULL);
4358 }
4359 
4360 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4361 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4362 {
4363     size_t size = 0;
4364     /* skip val->{sType,pNext} */
4365     size += vn_sizeof_VkBool32(&val->depthClipEnable);
4366     return size;
4367 }
4368 
4369 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4370 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4371 {
4372     size_t size = 0;
4373 
4374     size += vn_sizeof_VkStructureType(&val->sType);
4375     size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(val->pNext);
4376     size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(val);
4377 
4378     return size;
4379 }
4380 
4381 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)4382 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
4383 {
4384     /* no known/supported struct */
4385     vn_encode_simple_pointer(enc, NULL);
4386 }
4387 
4388 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4389 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4390 {
4391     /* skip val->{sType,pNext} */
4392     vn_encode_VkBool32(enc, &val->depthClipEnable);
4393 }
4394 
4395 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4396 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4397 {
4398     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
4399     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT });
4400     vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(enc, val->pNext);
4401     vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(enc, val);
4402 }
4403 
4404 static inline void
vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)4405 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
4406 {
4407     /* no known/supported struct */
4408     if (vn_decode_simple_pointer(dec))
4409         assert(false);
4410 }
4411 
4412 static inline void
vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4413 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4414 {
4415     /* skip val->{sType,pNext} */
4416     vn_decode_VkBool32(dec, &val->depthClipEnable);
4417 }
4418 
4419 static inline void
vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4420 vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4421 {
4422     VkStructureType stype;
4423     vn_decode_VkStructureType(dec, &stype);
4424     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
4425 
4426     assert(val->sType == stype);
4427     vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext(dec, val->pNext);
4428     vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(dec, val);
4429 }
4430 
4431 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(const void * val)4432 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(const void *val)
4433 {
4434     /* no known/supported struct */
4435     return vn_sizeof_simple_pointer(NULL);
4436 }
4437 
4438 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4439 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4440 {
4441     size_t size = 0;
4442     /* skip val->{sType,pNext} */
4443     /* skip val->depthClipEnable */
4444     return size;
4445 }
4446 
4447 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4448 vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4449 {
4450     size_t size = 0;
4451 
4452     size += vn_sizeof_VkStructureType(&val->sType);
4453     size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(val->pNext);
4454     size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(val);
4455 
4456     return size;
4457 }
4458 
4459 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)4460 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4461 {
4462     /* no known/supported struct */
4463     vn_encode_simple_pointer(enc, NULL);
4464 }
4465 
4466 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4467 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4468 {
4469     /* skip val->{sType,pNext} */
4470     /* skip val->depthClipEnable */
4471 }
4472 
4473 static inline void
vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthClipEnableFeaturesEXT * val)4474 vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *val)
4475 {
4476     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
4477     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT });
4478     vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_pnext_partial(enc, val->pNext);
4479     vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(enc, val);
4480 }
4481 
4482 /* struct VkPhysicalDeviceBufferDeviceAddressFeatures chain */
4483 
4484 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void * val)4485 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(const void *val)
4486 {
4487     /* no known/supported struct */
4488     return vn_sizeof_simple_pointer(NULL);
4489 }
4490 
4491 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4492 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4493 {
4494     size_t size = 0;
4495     /* skip val->{sType,pNext} */
4496     size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
4497     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
4498     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
4499     return size;
4500 }
4501 
4502 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4503 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4504 {
4505     size_t size = 0;
4506 
4507     size += vn_sizeof_VkStructureType(&val->sType);
4508     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(val->pNext);
4509     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self(val);
4510 
4511     return size;
4512 }
4513 
4514 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4515 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
4516 {
4517     /* no known/supported struct */
4518     vn_encode_simple_pointer(enc, NULL);
4519 }
4520 
4521 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4522 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4523 {
4524     /* skip val->{sType,pNext} */
4525     vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
4526     vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
4527     vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
4528 }
4529 
4530 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4531 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4532 {
4533     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
4534     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
4535     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(enc, val->pNext);
4536     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, val);
4537 }
4538 
4539 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4540 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
4541 {
4542     /* no known/supported struct */
4543     if (vn_decode_simple_pointer(dec))
4544         assert(false);
4545 }
4546 
4547 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)4548 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4549 {
4550     /* skip val->{sType,pNext} */
4551     vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
4552     vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
4553     vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
4554 }
4555 
4556 static inline void
vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceBufferDeviceAddressFeatures * val)4557 vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4558 {
4559     VkStructureType stype;
4560     vn_decode_VkStructureType(dec, &stype);
4561     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
4562 
4563     assert(val->sType == stype);
4564     vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext(dec, val->pNext);
4565     vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, val);
4566 }
4567 
4568 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void * val)4569 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(const void *val)
4570 {
4571     /* no known/supported struct */
4572     return vn_sizeof_simple_pointer(NULL);
4573 }
4574 
4575 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4576 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4577 {
4578     size_t size = 0;
4579     /* skip val->{sType,pNext} */
4580     /* skip val->bufferDeviceAddress */
4581     /* skip val->bufferDeviceAddressCaptureReplay */
4582     /* skip val->bufferDeviceAddressMultiDevice */
4583     return size;
4584 }
4585 
4586 static inline size_t
vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4587 vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4588 {
4589     size_t size = 0;
4590 
4591     size += vn_sizeof_VkStructureType(&val->sType);
4592     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(val->pNext);
4593     size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(val);
4594 
4595     return size;
4596 }
4597 
4598 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4599 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4600 {
4601     /* no known/supported struct */
4602     vn_encode_simple_pointer(enc, NULL);
4603 }
4604 
4605 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4606 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4607 {
4608     /* skip val->{sType,pNext} */
4609     /* skip val->bufferDeviceAddress */
4610     /* skip val->bufferDeviceAddressCaptureReplay */
4611     /* skip val->bufferDeviceAddressMultiDevice */
4612 }
4613 
4614 static inline void
vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceBufferDeviceAddressFeatures * val)4615 vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceBufferDeviceAddressFeatures *val)
4616 {
4617     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
4618     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES });
4619     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_pnext_partial(enc, val->pNext);
4620     vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, val);
4621 }
4622 
4623 /* struct VkPhysicalDeviceImagelessFramebufferFeatures chain */
4624 
4625 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void * val)4626 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(const void *val)
4627 {
4628     /* no known/supported struct */
4629     return vn_sizeof_simple_pointer(NULL);
4630 }
4631 
4632 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4633 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4634 {
4635     size_t size = 0;
4636     /* skip val->{sType,pNext} */
4637     size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
4638     return size;
4639 }
4640 
4641 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4642 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4643 {
4644     size_t size = 0;
4645 
4646     size += vn_sizeof_VkStructureType(&val->sType);
4647     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(val->pNext);
4648     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self(val);
4649 
4650     return size;
4651 }
4652 
4653 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4654 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
4655 {
4656     /* no known/supported struct */
4657     vn_encode_simple_pointer(enc, NULL);
4658 }
4659 
4660 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)4661 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4662 {
4663     /* skip val->{sType,pNext} */
4664     vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
4665 }
4666 
4667 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)4668 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4669 {
4670     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
4671     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
4672     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(enc, val->pNext);
4673     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, val);
4674 }
4675 
4676 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4677 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
4678 {
4679     /* no known/supported struct */
4680     if (vn_decode_simple_pointer(dec))
4681         assert(false);
4682 }
4683 
4684 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)4685 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
4686 {
4687     /* skip val->{sType,pNext} */
4688     vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
4689 }
4690 
4691 static inline void
vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceImagelessFramebufferFeatures * val)4692 vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImagelessFramebufferFeatures *val)
4693 {
4694     VkStructureType stype;
4695     vn_decode_VkStructureType(dec, &stype);
4696     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
4697 
4698     assert(val->sType == stype);
4699     vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext(dec, val->pNext);
4700     vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, val);
4701 }
4702 
4703 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void * val)4704 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(const void *val)
4705 {
4706     /* no known/supported struct */
4707     return vn_sizeof_simple_pointer(NULL);
4708 }
4709 
4710 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4711 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4712 {
4713     size_t size = 0;
4714     /* skip val->{sType,pNext} */
4715     /* skip val->imagelessFramebuffer */
4716     return size;
4717 }
4718 
4719 static inline size_t
vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures * val)4720 vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_partial(const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4721 {
4722     size_t size = 0;
4723 
4724     size += vn_sizeof_VkStructureType(&val->sType);
4725     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(val->pNext);
4726     size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(val);
4727 
4728     return size;
4729 }
4730 
4731 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4732 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4733 {
4734     /* no known/supported struct */
4735     vn_encode_simple_pointer(enc, NULL);
4736 }
4737 
4738 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)4739 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4740 {
4741     /* skip val->{sType,pNext} */
4742     /* skip val->imagelessFramebuffer */
4743 }
4744 
4745 static inline void
vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImagelessFramebufferFeatures * val)4746 vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImagelessFramebufferFeatures *val)
4747 {
4748     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
4749     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES });
4750     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_pnext_partial(enc, val->pNext);
4751     vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, val);
4752 }
4753 
4754 /* struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures chain */
4755 
4756 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(const void * val)4757 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(const void *val)
4758 {
4759     /* no known/supported struct */
4760     return vn_sizeof_simple_pointer(NULL);
4761 }
4762 
4763 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4764 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4765 {
4766     size_t size = 0;
4767     /* skip val->{sType,pNext} */
4768     size += vn_sizeof_VkBool32(&val->textureCompressionASTC_HDR);
4769     return size;
4770 }
4771 
4772 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4773 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4774 {
4775     size_t size = 0;
4776 
4777     size += vn_sizeof_VkStructureType(&val->sType);
4778     size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(val->pNext);
4779     size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(val);
4780 
4781     return size;
4782 }
4783 
4784 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_encoder * enc,const void * val)4785 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
4786 {
4787     /* no known/supported struct */
4788     vn_encode_simple_pointer(enc, NULL);
4789 }
4790 
4791 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4792 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4793 {
4794     /* skip val->{sType,pNext} */
4795     vn_encode_VkBool32(enc, &val->textureCompressionASTC_HDR);
4796 }
4797 
4798 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4799 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4800 {
4801     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
4802     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES });
4803     vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(enc, val->pNext);
4804     vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, val);
4805 }
4806 
4807 static inline void
vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_decoder * dec,const void * val)4808 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
4809 {
4810     /* no known/supported struct */
4811     if (vn_decode_simple_pointer(dec))
4812         assert(false);
4813 }
4814 
4815 static inline void
vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4816 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4817 {
4818     /* skip val->{sType,pNext} */
4819     vn_decode_VkBool32(dec, &val->textureCompressionASTC_HDR);
4820 }
4821 
4822 static inline void
vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4823 vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4824 {
4825     VkStructureType stype;
4826     vn_decode_VkStructureType(dec, &stype);
4827     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
4828 
4829     assert(val->sType == stype);
4830     vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext(dec, val->pNext);
4831     vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(dec, val);
4832 }
4833 
4834 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(const void * val)4835 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(const void *val)
4836 {
4837     /* no known/supported struct */
4838     return vn_sizeof_simple_pointer(NULL);
4839 }
4840 
4841 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4842 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4843 {
4844     size_t size = 0;
4845     /* skip val->{sType,pNext} */
4846     /* skip val->textureCompressionASTC_HDR */
4847     return size;
4848 }
4849 
4850 static inline size_t
vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4851 vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4852 {
4853     size_t size = 0;
4854 
4855     size += vn_sizeof_VkStructureType(&val->sType);
4856     size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(val->pNext);
4857     size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(val);
4858 
4859     return size;
4860 }
4861 
4862 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)4863 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4864 {
4865     /* no known/supported struct */
4866     vn_encode_simple_pointer(enc, NULL);
4867 }
4868 
4869 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4870 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4871 {
4872     /* skip val->{sType,pNext} */
4873     /* skip val->textureCompressionASTC_HDR */
4874 }
4875 
4876 static inline void
vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTextureCompressionASTCHDRFeatures * val)4877 vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *val)
4878 {
4879     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
4880     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES });
4881     vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_pnext_partial(enc, val->pNext);
4882     vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(enc, val);
4883 }
4884 
4885 /* struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT chain */
4886 
4887 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(const void * val)4888 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(const void *val)
4889 {
4890     /* no known/supported struct */
4891     return vn_sizeof_simple_pointer(NULL);
4892 }
4893 
4894 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4895 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4896 {
4897     size_t size = 0;
4898     /* skip val->{sType,pNext} */
4899     size += vn_sizeof_VkBool32(&val->indexTypeUint8);
4900     return size;
4901 }
4902 
4903 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4904 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4905 {
4906     size_t size = 0;
4907 
4908     size += vn_sizeof_VkStructureType(&val->sType);
4909     size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(val->pNext);
4910     size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(val);
4911 
4912     return size;
4913 }
4914 
4915 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)4916 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
4917 {
4918     /* no known/supported struct */
4919     vn_encode_simple_pointer(enc, NULL);
4920 }
4921 
4922 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4923 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4924 {
4925     /* skip val->{sType,pNext} */
4926     vn_encode_VkBool32(enc, &val->indexTypeUint8);
4927 }
4928 
4929 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4930 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4931 {
4932     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
4933     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT });
4934     vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(enc, val->pNext);
4935     vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(enc, val);
4936 }
4937 
4938 static inline void
vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)4939 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
4940 {
4941     /* no known/supported struct */
4942     if (vn_decode_simple_pointer(dec))
4943         assert(false);
4944 }
4945 
4946 static inline void
vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4947 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4948 {
4949     /* skip val->{sType,pNext} */
4950     vn_decode_VkBool32(dec, &val->indexTypeUint8);
4951 }
4952 
4953 static inline void
vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4954 vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4955 {
4956     VkStructureType stype;
4957     vn_decode_VkStructureType(dec, &stype);
4958     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
4959 
4960     assert(val->sType == stype);
4961     vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext(dec, val->pNext);
4962     vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(dec, val);
4963 }
4964 
4965 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(const void * val)4966 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(const void *val)
4967 {
4968     /* no known/supported struct */
4969     return vn_sizeof_simple_pointer(NULL);
4970 }
4971 
4972 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4973 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4974 {
4975     size_t size = 0;
4976     /* skip val->{sType,pNext} */
4977     /* skip val->indexTypeUint8 */
4978     return size;
4979 }
4980 
4981 static inline size_t
vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)4982 vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
4983 {
4984     size_t size = 0;
4985 
4986     size += vn_sizeof_VkStructureType(&val->sType);
4987     size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(val->pNext);
4988     size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(val);
4989 
4990     return size;
4991 }
4992 
4993 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)4994 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
4995 {
4996     /* no known/supported struct */
4997     vn_encode_simple_pointer(enc, NULL);
4998 }
4999 
5000 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5001 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5002 {
5003     /* skip val->{sType,pNext} */
5004     /* skip val->indexTypeUint8 */
5005 }
5006 
5007 static inline void
vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIndexTypeUint8FeaturesEXT * val)5008 vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *val)
5009 {
5010     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
5011     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT });
5012     vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_pnext_partial(enc, val->pNext);
5013     vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(enc, val);
5014 }
5015 
5016 /* struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures chain */
5017 
5018 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void * val)5019 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(const void *val)
5020 {
5021     /* no known/supported struct */
5022     return vn_sizeof_simple_pointer(NULL);
5023 }
5024 
5025 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5026 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5027 {
5028     size_t size = 0;
5029     /* skip val->{sType,pNext} */
5030     size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
5031     return size;
5032 }
5033 
5034 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5035 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5036 {
5037     size_t size = 0;
5038 
5039     size += vn_sizeof_VkStructureType(&val->sType);
5040     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(val->pNext);
5041     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(val);
5042 
5043     return size;
5044 }
5045 
5046 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder * enc,const void * val)5047 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
5048 {
5049     /* no known/supported struct */
5050     vn_encode_simple_pointer(enc, NULL);
5051 }
5052 
5053 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5054 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5055 {
5056     /* skip val->{sType,pNext} */
5057     vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
5058 }
5059 
5060 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5061 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5062 {
5063     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
5064     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
5065     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(enc, val->pNext);
5066     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, val);
5067 }
5068 
5069 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder * dec,const void * val)5070 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
5071 {
5072     /* no known/supported struct */
5073     if (vn_decode_simple_pointer(dec))
5074         assert(false);
5075 }
5076 
5077 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5078 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5079 {
5080     /* skip val->{sType,pNext} */
5081     vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
5082 }
5083 
5084 static inline void
vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5085 vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5086 {
5087     VkStructureType stype;
5088     vn_decode_VkStructureType(dec, &stype);
5089     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
5090 
5091     assert(val->sType == stype);
5092     vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext(dec, val->pNext);
5093     vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, val);
5094 }
5095 
5096 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void * val)5097 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(const void *val)
5098 {
5099     /* no known/supported struct */
5100     return vn_sizeof_simple_pointer(NULL);
5101 }
5102 
5103 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5104 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5105 {
5106     size_t size = 0;
5107     /* skip val->{sType,pNext} */
5108     /* skip val->separateDepthStencilLayouts */
5109     return size;
5110 }
5111 
5112 static inline size_t
vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5113 vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5114 {
5115     size_t size = 0;
5116 
5117     size += vn_sizeof_VkStructureType(&val->sType);
5118     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(val->pNext);
5119     size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(val);
5120 
5121     return size;
5122 }
5123 
5124 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)5125 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5126 {
5127     /* no known/supported struct */
5128     vn_encode_simple_pointer(enc, NULL);
5129 }
5130 
5131 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5132 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5133 {
5134     /* skip val->{sType,pNext} */
5135     /* skip val->separateDepthStencilLayouts */
5136 }
5137 
5138 static inline void
vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures * val)5139 vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *val)
5140 {
5141     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
5142     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES });
5143     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_pnext_partial(enc, val->pNext);
5144     vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, val);
5145 }
5146 
5147 /* struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures chain */
5148 
5149 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(const void * val)5150 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(const void *val)
5151 {
5152     /* no known/supported struct */
5153     return vn_sizeof_simple_pointer(NULL);
5154 }
5155 
5156 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5157 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5158 {
5159     size_t size = 0;
5160     /* skip val->{sType,pNext} */
5161     size += vn_sizeof_VkBool32(&val->shaderDemoteToHelperInvocation);
5162     return size;
5163 }
5164 
5165 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5166 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5167 {
5168     size_t size = 0;
5169 
5170     size += vn_sizeof_VkStructureType(&val->sType);
5171     size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(val->pNext);
5172     size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(val);
5173 
5174     return size;
5175 }
5176 
5177 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_encoder * enc,const void * val)5178 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
5179 {
5180     /* no known/supported struct */
5181     vn_encode_simple_pointer(enc, NULL);
5182 }
5183 
5184 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5185 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5186 {
5187     /* skip val->{sType,pNext} */
5188     vn_encode_VkBool32(enc, &val->shaderDemoteToHelperInvocation);
5189 }
5190 
5191 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5192 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5193 {
5194     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
5195     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES });
5196     vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(enc, val->pNext);
5197     vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, val);
5198 }
5199 
5200 static inline void
vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_decoder * dec,const void * val)5201 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
5202 {
5203     /* no known/supported struct */
5204     if (vn_decode_simple_pointer(dec))
5205         assert(false);
5206 }
5207 
5208 static inline void
vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5209 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5210 {
5211     /* skip val->{sType,pNext} */
5212     vn_decode_VkBool32(dec, &val->shaderDemoteToHelperInvocation);
5213 }
5214 
5215 static inline void
vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5216 vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5217 {
5218     VkStructureType stype;
5219     vn_decode_VkStructureType(dec, &stype);
5220     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
5221 
5222     assert(val->sType == stype);
5223     vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext(dec, val->pNext);
5224     vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(dec, val);
5225 }
5226 
5227 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(const void * val)5228 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(const void *val)
5229 {
5230     /* no known/supported struct */
5231     return vn_sizeof_simple_pointer(NULL);
5232 }
5233 
5234 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5235 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5236 {
5237     size_t size = 0;
5238     /* skip val->{sType,pNext} */
5239     /* skip val->shaderDemoteToHelperInvocation */
5240     return size;
5241 }
5242 
5243 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5244 vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5245 {
5246     size_t size = 0;
5247 
5248     size += vn_sizeof_VkStructureType(&val->sType);
5249     size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(val->pNext);
5250     size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(val);
5251 
5252     return size;
5253 }
5254 
5255 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)5256 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5257 {
5258     /* no known/supported struct */
5259     vn_encode_simple_pointer(enc, NULL);
5260 }
5261 
5262 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5263 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5264 {
5265     /* skip val->{sType,pNext} */
5266     /* skip val->shaderDemoteToHelperInvocation */
5267 }
5268 
5269 static inline void
vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures * val)5270 vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *val)
5271 {
5272     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
5273     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES });
5274     vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_pnext_partial(enc, val->pNext);
5275     vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(enc, val);
5276 }
5277 
5278 /* struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT chain */
5279 
5280 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(const void * val)5281 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(const void *val)
5282 {
5283     /* no known/supported struct */
5284     return vn_sizeof_simple_pointer(NULL);
5285 }
5286 
5287 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5288 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5289 {
5290     size_t size = 0;
5291     /* skip val->{sType,pNext} */
5292     size += vn_sizeof_VkBool32(&val->texelBufferAlignment);
5293     return size;
5294 }
5295 
5296 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5297 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5298 {
5299     size_t size = 0;
5300 
5301     size += vn_sizeof_VkStructureType(&val->sType);
5302     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(val->pNext);
5303     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(val);
5304 
5305     return size;
5306 }
5307 
5308 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)5309 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
5310 {
5311     /* no known/supported struct */
5312     vn_encode_simple_pointer(enc, NULL);
5313 }
5314 
5315 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5316 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5317 {
5318     /* skip val->{sType,pNext} */
5319     vn_encode_VkBool32(enc, &val->texelBufferAlignment);
5320 }
5321 
5322 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5323 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5324 {
5325     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
5326     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT });
5327     vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(enc, val->pNext);
5328     vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, val);
5329 }
5330 
5331 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)5332 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
5333 {
5334     /* no known/supported struct */
5335     if (vn_decode_simple_pointer(dec))
5336         assert(false);
5337 }
5338 
5339 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5340 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5341 {
5342     /* skip val->{sType,pNext} */
5343     vn_decode_VkBool32(dec, &val->texelBufferAlignment);
5344 }
5345 
5346 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5347 vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5348 {
5349     VkStructureType stype;
5350     vn_decode_VkStructureType(dec, &stype);
5351     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
5352 
5353     assert(val->sType == stype);
5354     vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext(dec, val->pNext);
5355     vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(dec, val);
5356 }
5357 
5358 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(const void * val)5359 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(const void *val)
5360 {
5361     /* no known/supported struct */
5362     return vn_sizeof_simple_pointer(NULL);
5363 }
5364 
5365 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5366 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5367 {
5368     size_t size = 0;
5369     /* skip val->{sType,pNext} */
5370     /* skip val->texelBufferAlignment */
5371     return size;
5372 }
5373 
5374 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5375 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5376 {
5377     size_t size = 0;
5378 
5379     size += vn_sizeof_VkStructureType(&val->sType);
5380     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(val->pNext);
5381     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(val);
5382 
5383     return size;
5384 }
5385 
5386 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)5387 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5388 {
5389     /* no known/supported struct */
5390     vn_encode_simple_pointer(enc, NULL);
5391 }
5392 
5393 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5394 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5395 {
5396     /* skip val->{sType,pNext} */
5397     /* skip val->texelBufferAlignment */
5398 }
5399 
5400 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT * val)5401 vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *val)
5402 {
5403     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
5404     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT });
5405     vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_pnext_partial(enc, val->pNext);
5406     vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(enc, val);
5407 }
5408 
5409 /* struct VkPhysicalDeviceSubgroupSizeControlFeatures chain */
5410 
5411 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(const void * val)5412 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(const void *val)
5413 {
5414     /* no known/supported struct */
5415     return vn_sizeof_simple_pointer(NULL);
5416 }
5417 
5418 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5419 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5420 {
5421     size_t size = 0;
5422     /* skip val->{sType,pNext} */
5423     size += vn_sizeof_VkBool32(&val->subgroupSizeControl);
5424     size += vn_sizeof_VkBool32(&val->computeFullSubgroups);
5425     return size;
5426 }
5427 
5428 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5429 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5430 {
5431     size_t size = 0;
5432 
5433     size += vn_sizeof_VkStructureType(&val->sType);
5434     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(val->pNext);
5435     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self(val);
5436 
5437     return size;
5438 }
5439 
5440 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_encoder * enc,const void * val)5441 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
5442 {
5443     /* no known/supported struct */
5444     vn_encode_simple_pointer(enc, NULL);
5445 }
5446 
5447 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5448 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5449 {
5450     /* skip val->{sType,pNext} */
5451     vn_encode_VkBool32(enc, &val->subgroupSizeControl);
5452     vn_encode_VkBool32(enc, &val->computeFullSubgroups);
5453 }
5454 
5455 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5456 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5457 {
5458     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
5459     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES });
5460     vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(enc, val->pNext);
5461     vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, val);
5462 }
5463 
5464 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_decoder * dec,const void * val)5465 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
5466 {
5467     /* no known/supported struct */
5468     if (vn_decode_simple_pointer(dec))
5469         assert(false);
5470 }
5471 
5472 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlFeatures * val)5473 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5474 {
5475     /* skip val->{sType,pNext} */
5476     vn_decode_VkBool32(dec, &val->subgroupSizeControl);
5477     vn_decode_VkBool32(dec, &val->computeFullSubgroups);
5478 }
5479 
5480 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlFeatures * val)5481 vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5482 {
5483     VkStructureType stype;
5484     vn_decode_VkStructureType(dec, &stype);
5485     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
5486 
5487     assert(val->sType == stype);
5488     vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext(dec, val->pNext);
5489     vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(dec, val);
5490 }
5491 
5492 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(const void * val)5493 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(const void *val)
5494 {
5495     /* no known/supported struct */
5496     return vn_sizeof_simple_pointer(NULL);
5497 }
5498 
5499 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5500 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5501 {
5502     size_t size = 0;
5503     /* skip val->{sType,pNext} */
5504     /* skip val->subgroupSizeControl */
5505     /* skip val->computeFullSubgroups */
5506     return size;
5507 }
5508 
5509 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5510 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5511 {
5512     size_t size = 0;
5513 
5514     size += vn_sizeof_VkStructureType(&val->sType);
5515     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(val->pNext);
5516     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(val);
5517 
5518     return size;
5519 }
5520 
5521 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)5522 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5523 {
5524     /* no known/supported struct */
5525     vn_encode_simple_pointer(enc, NULL);
5526 }
5527 
5528 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5529 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5530 {
5531     /* skip val->{sType,pNext} */
5532     /* skip val->subgroupSizeControl */
5533     /* skip val->computeFullSubgroups */
5534 }
5535 
5536 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlFeatures * val)5537 vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlFeatures *val)
5538 {
5539     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
5540     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES });
5541     vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_pnext_partial(enc, val->pNext);
5542     vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(enc, val);
5543 }
5544 
5545 /* struct VkPhysicalDeviceLineRasterizationFeaturesEXT chain */
5546 
5547 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(const void * val)5548 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(const void *val)
5549 {
5550     /* no known/supported struct */
5551     return vn_sizeof_simple_pointer(NULL);
5552 }
5553 
5554 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5555 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5556 {
5557     size_t size = 0;
5558     /* skip val->{sType,pNext} */
5559     size += vn_sizeof_VkBool32(&val->rectangularLines);
5560     size += vn_sizeof_VkBool32(&val->bresenhamLines);
5561     size += vn_sizeof_VkBool32(&val->smoothLines);
5562     size += vn_sizeof_VkBool32(&val->stippledRectangularLines);
5563     size += vn_sizeof_VkBool32(&val->stippledBresenhamLines);
5564     size += vn_sizeof_VkBool32(&val->stippledSmoothLines);
5565     return size;
5566 }
5567 
5568 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5569 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5570 {
5571     size_t size = 0;
5572 
5573     size += vn_sizeof_VkStructureType(&val->sType);
5574     size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(val->pNext);
5575     size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(val);
5576 
5577     return size;
5578 }
5579 
5580 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)5581 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
5582 {
5583     /* no known/supported struct */
5584     vn_encode_simple_pointer(enc, NULL);
5585 }
5586 
5587 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5588 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5589 {
5590     /* skip val->{sType,pNext} */
5591     vn_encode_VkBool32(enc, &val->rectangularLines);
5592     vn_encode_VkBool32(enc, &val->bresenhamLines);
5593     vn_encode_VkBool32(enc, &val->smoothLines);
5594     vn_encode_VkBool32(enc, &val->stippledRectangularLines);
5595     vn_encode_VkBool32(enc, &val->stippledBresenhamLines);
5596     vn_encode_VkBool32(enc, &val->stippledSmoothLines);
5597 }
5598 
5599 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5600 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5601 {
5602     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
5603     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT });
5604     vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(enc, val->pNext);
5605     vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(enc, val);
5606 }
5607 
5608 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)5609 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
5610 {
5611     /* no known/supported struct */
5612     if (vn_decode_simple_pointer(dec))
5613         assert(false);
5614 }
5615 
5616 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5617 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5618 {
5619     /* skip val->{sType,pNext} */
5620     vn_decode_VkBool32(dec, &val->rectangularLines);
5621     vn_decode_VkBool32(dec, &val->bresenhamLines);
5622     vn_decode_VkBool32(dec, &val->smoothLines);
5623     vn_decode_VkBool32(dec, &val->stippledRectangularLines);
5624     vn_decode_VkBool32(dec, &val->stippledBresenhamLines);
5625     vn_decode_VkBool32(dec, &val->stippledSmoothLines);
5626 }
5627 
5628 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5629 vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5630 {
5631     VkStructureType stype;
5632     vn_decode_VkStructureType(dec, &stype);
5633     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
5634 
5635     assert(val->sType == stype);
5636     vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext(dec, val->pNext);
5637     vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(dec, val);
5638 }
5639 
5640 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(const void * val)5641 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(const void *val)
5642 {
5643     /* no known/supported struct */
5644     return vn_sizeof_simple_pointer(NULL);
5645 }
5646 
5647 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5648 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5649 {
5650     size_t size = 0;
5651     /* skip val->{sType,pNext} */
5652     /* skip val->rectangularLines */
5653     /* skip val->bresenhamLines */
5654     /* skip val->smoothLines */
5655     /* skip val->stippledRectangularLines */
5656     /* skip val->stippledBresenhamLines */
5657     /* skip val->stippledSmoothLines */
5658     return size;
5659 }
5660 
5661 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5662 vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5663 {
5664     size_t size = 0;
5665 
5666     size += vn_sizeof_VkStructureType(&val->sType);
5667     size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(val->pNext);
5668     size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(val);
5669 
5670     return size;
5671 }
5672 
5673 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)5674 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5675 {
5676     /* no known/supported struct */
5677     vn_encode_simple_pointer(enc, NULL);
5678 }
5679 
5680 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5681 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5682 {
5683     /* skip val->{sType,pNext} */
5684     /* skip val->rectangularLines */
5685     /* skip val->bresenhamLines */
5686     /* skip val->smoothLines */
5687     /* skip val->stippledRectangularLines */
5688     /* skip val->stippledBresenhamLines */
5689     /* skip val->stippledSmoothLines */
5690 }
5691 
5692 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationFeaturesEXT * val)5693 vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationFeaturesEXT *val)
5694 {
5695     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
5696     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT });
5697     vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_pnext_partial(enc, val->pNext);
5698     vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(enc, val);
5699 }
5700 
5701 /* struct VkPhysicalDevicePipelineCreationCacheControlFeatures chain */
5702 
5703 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(const void * val)5704 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(const void *val)
5705 {
5706     /* no known/supported struct */
5707     return vn_sizeof_simple_pointer(NULL);
5708 }
5709 
5710 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5711 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5712 {
5713     size_t size = 0;
5714     /* skip val->{sType,pNext} */
5715     size += vn_sizeof_VkBool32(&val->pipelineCreationCacheControl);
5716     return size;
5717 }
5718 
5719 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5720 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5721 {
5722     size_t size = 0;
5723 
5724     size += vn_sizeof_VkStructureType(&val->sType);
5725     size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(val->pNext);
5726     size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(val);
5727 
5728     return size;
5729 }
5730 
5731 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_encoder * enc,const void * val)5732 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
5733 {
5734     /* no known/supported struct */
5735     vn_encode_simple_pointer(enc, NULL);
5736 }
5737 
5738 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5739 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5740 {
5741     /* skip val->{sType,pNext} */
5742     vn_encode_VkBool32(enc, &val->pipelineCreationCacheControl);
5743 }
5744 
5745 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5746 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5747 {
5748     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
5749     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES });
5750     vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(enc, val->pNext);
5751     vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, val);
5752 }
5753 
5754 static inline void
vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_decoder * dec,const void * val)5755 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
5756 {
5757     /* no known/supported struct */
5758     if (vn_decode_simple_pointer(dec))
5759         assert(false);
5760 }
5761 
5762 static inline void
vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5763 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5764 {
5765     /* skip val->{sType,pNext} */
5766     vn_decode_VkBool32(dec, &val->pipelineCreationCacheControl);
5767 }
5768 
5769 static inline void
vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_decoder * dec,VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5770 vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures(struct vn_cs_decoder *dec, VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5771 {
5772     VkStructureType stype;
5773     vn_decode_VkStructureType(dec, &stype);
5774     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
5775 
5776     assert(val->sType == stype);
5777     vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext(dec, val->pNext);
5778     vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(dec, val);
5779 }
5780 
5781 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(const void * val)5782 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(const void *val)
5783 {
5784     /* no known/supported struct */
5785     return vn_sizeof_simple_pointer(NULL);
5786 }
5787 
5788 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5789 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5790 {
5791     size_t size = 0;
5792     /* skip val->{sType,pNext} */
5793     /* skip val->pipelineCreationCacheControl */
5794     return size;
5795 }
5796 
5797 static inline size_t
vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5798 vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5799 {
5800     size_t size = 0;
5801 
5802     size += vn_sizeof_VkStructureType(&val->sType);
5803     size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(val->pNext);
5804     size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(val);
5805 
5806     return size;
5807 }
5808 
5809 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)5810 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5811 {
5812     /* no known/supported struct */
5813     vn_encode_simple_pointer(enc, NULL);
5814 }
5815 
5816 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5817 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5818 {
5819     /* skip val->{sType,pNext} */
5820     /* skip val->pipelineCreationCacheControl */
5821 }
5822 
5823 static inline void
vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePipelineCreationCacheControlFeatures * val)5824 vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePipelineCreationCacheControlFeatures *val)
5825 {
5826     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
5827     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES });
5828     vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_pnext_partial(enc, val->pNext);
5829     vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(enc, val);
5830 }
5831 
5832 /* struct VkPhysicalDeviceVulkan11Features chain */
5833 
5834 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void * val)5835 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(const void *val)
5836 {
5837     /* no known/supported struct */
5838     return vn_sizeof_simple_pointer(NULL);
5839 }
5840 
5841 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features * val)5842 vn_sizeof_VkPhysicalDeviceVulkan11Features_self(const VkPhysicalDeviceVulkan11Features *val)
5843 {
5844     size_t size = 0;
5845     /* skip val->{sType,pNext} */
5846     size += vn_sizeof_VkBool32(&val->storageBuffer16BitAccess);
5847     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer16BitAccess);
5848     size += vn_sizeof_VkBool32(&val->storagePushConstant16);
5849     size += vn_sizeof_VkBool32(&val->storageInputOutput16);
5850     size += vn_sizeof_VkBool32(&val->multiview);
5851     size += vn_sizeof_VkBool32(&val->multiviewGeometryShader);
5852     size += vn_sizeof_VkBool32(&val->multiviewTessellationShader);
5853     size += vn_sizeof_VkBool32(&val->variablePointersStorageBuffer);
5854     size += vn_sizeof_VkBool32(&val->variablePointers);
5855     size += vn_sizeof_VkBool32(&val->protectedMemory);
5856     size += vn_sizeof_VkBool32(&val->samplerYcbcrConversion);
5857     size += vn_sizeof_VkBool32(&val->shaderDrawParameters);
5858     return size;
5859 }
5860 
5861 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features * val)5862 vn_sizeof_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features *val)
5863 {
5864     size_t size = 0;
5865 
5866     size += vn_sizeof_VkStructureType(&val->sType);
5867     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext(val->pNext);
5868     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self(val);
5869 
5870     return size;
5871 }
5872 
5873 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder * enc,const void * val)5874 vn_encode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_encoder *enc, const void *val)
5875 {
5876     /* no known/supported struct */
5877     vn_encode_simple_pointer(enc, NULL);
5878 }
5879 
5880 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)5881 vn_encode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
5882 {
5883     /* skip val->{sType,pNext} */
5884     vn_encode_VkBool32(enc, &val->storageBuffer16BitAccess);
5885     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer16BitAccess);
5886     vn_encode_VkBool32(enc, &val->storagePushConstant16);
5887     vn_encode_VkBool32(enc, &val->storageInputOutput16);
5888     vn_encode_VkBool32(enc, &val->multiview);
5889     vn_encode_VkBool32(enc, &val->multiviewGeometryShader);
5890     vn_encode_VkBool32(enc, &val->multiviewTessellationShader);
5891     vn_encode_VkBool32(enc, &val->variablePointersStorageBuffer);
5892     vn_encode_VkBool32(enc, &val->variablePointers);
5893     vn_encode_VkBool32(enc, &val->protectedMemory);
5894     vn_encode_VkBool32(enc, &val->samplerYcbcrConversion);
5895     vn_encode_VkBool32(enc, &val->shaderDrawParameters);
5896 }
5897 
5898 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)5899 vn_encode_VkPhysicalDeviceVulkan11Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
5900 {
5901     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
5902     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
5903     vn_encode_VkPhysicalDeviceVulkan11Features_pnext(enc, val->pNext);
5904     vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, val);
5905 }
5906 
5907 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder * dec,const void * val)5908 vn_decode_VkPhysicalDeviceVulkan11Features_pnext(struct vn_cs_decoder *dec, const void *val)
5909 {
5910     /* no known/supported struct */
5911     if (vn_decode_simple_pointer(dec))
5912         assert(false);
5913 }
5914 
5915 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)5916 vn_decode_VkPhysicalDeviceVulkan11Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
5917 {
5918     /* skip val->{sType,pNext} */
5919     vn_decode_VkBool32(dec, &val->storageBuffer16BitAccess);
5920     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer16BitAccess);
5921     vn_decode_VkBool32(dec, &val->storagePushConstant16);
5922     vn_decode_VkBool32(dec, &val->storageInputOutput16);
5923     vn_decode_VkBool32(dec, &val->multiview);
5924     vn_decode_VkBool32(dec, &val->multiviewGeometryShader);
5925     vn_decode_VkBool32(dec, &val->multiviewTessellationShader);
5926     vn_decode_VkBool32(dec, &val->variablePointersStorageBuffer);
5927     vn_decode_VkBool32(dec, &val->variablePointers);
5928     vn_decode_VkBool32(dec, &val->protectedMemory);
5929     vn_decode_VkBool32(dec, &val->samplerYcbcrConversion);
5930     vn_decode_VkBool32(dec, &val->shaderDrawParameters);
5931 }
5932 
5933 static inline void
vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Features * val)5934 vn_decode_VkPhysicalDeviceVulkan11Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Features *val)
5935 {
5936     VkStructureType stype;
5937     vn_decode_VkStructureType(dec, &stype);
5938     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
5939 
5940     assert(val->sType == stype);
5941     vn_decode_VkPhysicalDeviceVulkan11Features_pnext(dec, val->pNext);
5942     vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, val);
5943 }
5944 
5945 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void * val)5946 vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(const void *val)
5947 {
5948     /* no known/supported struct */
5949     return vn_sizeof_simple_pointer(NULL);
5950 }
5951 
5952 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features * val)5953 vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(const VkPhysicalDeviceVulkan11Features *val)
5954 {
5955     size_t size = 0;
5956     /* skip val->{sType,pNext} */
5957     /* skip val->storageBuffer16BitAccess */
5958     /* skip val->uniformAndStorageBuffer16BitAccess */
5959     /* skip val->storagePushConstant16 */
5960     /* skip val->storageInputOutput16 */
5961     /* skip val->multiview */
5962     /* skip val->multiviewGeometryShader */
5963     /* skip val->multiviewTessellationShader */
5964     /* skip val->variablePointersStorageBuffer */
5965     /* skip val->variablePointers */
5966     /* skip val->protectedMemory */
5967     /* skip val->samplerYcbcrConversion */
5968     /* skip val->shaderDrawParameters */
5969     return size;
5970 }
5971 
5972 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features * val)5973 vn_sizeof_VkPhysicalDeviceVulkan11Features_partial(const VkPhysicalDeviceVulkan11Features *val)
5974 {
5975     size_t size = 0;
5976 
5977     size += vn_sizeof_VkStructureType(&val->sType);
5978     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_pnext_partial(val->pNext);
5979     size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial(val);
5980 
5981     return size;
5982 }
5983 
5984 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)5985 vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
5986 {
5987     /* no known/supported struct */
5988     vn_encode_simple_pointer(enc, NULL);
5989 }
5990 
5991 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)5992 vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
5993 {
5994     /* skip val->{sType,pNext} */
5995     /* skip val->storageBuffer16BitAccess */
5996     /* skip val->uniformAndStorageBuffer16BitAccess */
5997     /* skip val->storagePushConstant16 */
5998     /* skip val->storageInputOutput16 */
5999     /* skip val->multiview */
6000     /* skip val->multiviewGeometryShader */
6001     /* skip val->multiviewTessellationShader */
6002     /* skip val->variablePointersStorageBuffer */
6003     /* skip val->variablePointers */
6004     /* skip val->protectedMemory */
6005     /* skip val->samplerYcbcrConversion */
6006     /* skip val->shaderDrawParameters */
6007 }
6008 
6009 static inline void
vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Features * val)6010 vn_encode_VkPhysicalDeviceVulkan11Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Features *val)
6011 {
6012     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
6013     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES });
6014     vn_encode_VkPhysicalDeviceVulkan11Features_pnext_partial(enc, val->pNext);
6015     vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, val);
6016 }
6017 
6018 /* struct VkPhysicalDeviceVulkan12Features chain */
6019 
6020 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void * val)6021 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(const void *val)
6022 {
6023     /* no known/supported struct */
6024     return vn_sizeof_simple_pointer(NULL);
6025 }
6026 
6027 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features * val)6028 vn_sizeof_VkPhysicalDeviceVulkan12Features_self(const VkPhysicalDeviceVulkan12Features *val)
6029 {
6030     size_t size = 0;
6031     /* skip val->{sType,pNext} */
6032     size += vn_sizeof_VkBool32(&val->samplerMirrorClampToEdge);
6033     size += vn_sizeof_VkBool32(&val->drawIndirectCount);
6034     size += vn_sizeof_VkBool32(&val->storageBuffer8BitAccess);
6035     size += vn_sizeof_VkBool32(&val->uniformAndStorageBuffer8BitAccess);
6036     size += vn_sizeof_VkBool32(&val->storagePushConstant8);
6037     size += vn_sizeof_VkBool32(&val->shaderBufferInt64Atomics);
6038     size += vn_sizeof_VkBool32(&val->shaderSharedInt64Atomics);
6039     size += vn_sizeof_VkBool32(&val->shaderFloat16);
6040     size += vn_sizeof_VkBool32(&val->shaderInt8);
6041     size += vn_sizeof_VkBool32(&val->descriptorIndexing);
6042     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayDynamicIndexing);
6043     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayDynamicIndexing);
6044     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayDynamicIndexing);
6045     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexing);
6046     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexing);
6047     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexing);
6048     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexing);
6049     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexing);
6050     size += vn_sizeof_VkBool32(&val->shaderUniformTexelBufferArrayNonUniformIndexing);
6051     size += vn_sizeof_VkBool32(&val->shaderStorageTexelBufferArrayNonUniformIndexing);
6052     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformBufferUpdateAfterBind);
6053     size += vn_sizeof_VkBool32(&val->descriptorBindingSampledImageUpdateAfterBind);
6054     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageImageUpdateAfterBind);
6055     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageBufferUpdateAfterBind);
6056     size += vn_sizeof_VkBool32(&val->descriptorBindingUniformTexelBufferUpdateAfterBind);
6057     size += vn_sizeof_VkBool32(&val->descriptorBindingStorageTexelBufferUpdateAfterBind);
6058     size += vn_sizeof_VkBool32(&val->descriptorBindingUpdateUnusedWhilePending);
6059     size += vn_sizeof_VkBool32(&val->descriptorBindingPartiallyBound);
6060     size += vn_sizeof_VkBool32(&val->descriptorBindingVariableDescriptorCount);
6061     size += vn_sizeof_VkBool32(&val->runtimeDescriptorArray);
6062     size += vn_sizeof_VkBool32(&val->samplerFilterMinmax);
6063     size += vn_sizeof_VkBool32(&val->scalarBlockLayout);
6064     size += vn_sizeof_VkBool32(&val->imagelessFramebuffer);
6065     size += vn_sizeof_VkBool32(&val->uniformBufferStandardLayout);
6066     size += vn_sizeof_VkBool32(&val->shaderSubgroupExtendedTypes);
6067     size += vn_sizeof_VkBool32(&val->separateDepthStencilLayouts);
6068     size += vn_sizeof_VkBool32(&val->hostQueryReset);
6069     size += vn_sizeof_VkBool32(&val->timelineSemaphore);
6070     size += vn_sizeof_VkBool32(&val->bufferDeviceAddress);
6071     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressCaptureReplay);
6072     size += vn_sizeof_VkBool32(&val->bufferDeviceAddressMultiDevice);
6073     size += vn_sizeof_VkBool32(&val->vulkanMemoryModel);
6074     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelDeviceScope);
6075     size += vn_sizeof_VkBool32(&val->vulkanMemoryModelAvailabilityVisibilityChains);
6076     size += vn_sizeof_VkBool32(&val->shaderOutputViewportIndex);
6077     size += vn_sizeof_VkBool32(&val->shaderOutputLayer);
6078     size += vn_sizeof_VkBool32(&val->subgroupBroadcastDynamicId);
6079     return size;
6080 }
6081 
6082 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features * val)6083 vn_sizeof_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features *val)
6084 {
6085     size_t size = 0;
6086 
6087     size += vn_sizeof_VkStructureType(&val->sType);
6088     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext(val->pNext);
6089     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self(val);
6090 
6091     return size;
6092 }
6093 
6094 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder * enc,const void * val)6095 vn_encode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_encoder *enc, const void *val)
6096 {
6097     /* no known/supported struct */
6098     vn_encode_simple_pointer(enc, NULL);
6099 }
6100 
6101 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)6102 vn_encode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
6103 {
6104     /* skip val->{sType,pNext} */
6105     vn_encode_VkBool32(enc, &val->samplerMirrorClampToEdge);
6106     vn_encode_VkBool32(enc, &val->drawIndirectCount);
6107     vn_encode_VkBool32(enc, &val->storageBuffer8BitAccess);
6108     vn_encode_VkBool32(enc, &val->uniformAndStorageBuffer8BitAccess);
6109     vn_encode_VkBool32(enc, &val->storagePushConstant8);
6110     vn_encode_VkBool32(enc, &val->shaderBufferInt64Atomics);
6111     vn_encode_VkBool32(enc, &val->shaderSharedInt64Atomics);
6112     vn_encode_VkBool32(enc, &val->shaderFloat16);
6113     vn_encode_VkBool32(enc, &val->shaderInt8);
6114     vn_encode_VkBool32(enc, &val->descriptorIndexing);
6115     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayDynamicIndexing);
6116     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayDynamicIndexing);
6117     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayDynamicIndexing);
6118     vn_encode_VkBool32(enc, &val->shaderUniformBufferArrayNonUniformIndexing);
6119     vn_encode_VkBool32(enc, &val->shaderSampledImageArrayNonUniformIndexing);
6120     vn_encode_VkBool32(enc, &val->shaderStorageBufferArrayNonUniformIndexing);
6121     vn_encode_VkBool32(enc, &val->shaderStorageImageArrayNonUniformIndexing);
6122     vn_encode_VkBool32(enc, &val->shaderInputAttachmentArrayNonUniformIndexing);
6123     vn_encode_VkBool32(enc, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
6124     vn_encode_VkBool32(enc, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
6125     vn_encode_VkBool32(enc, &val->descriptorBindingUniformBufferUpdateAfterBind);
6126     vn_encode_VkBool32(enc, &val->descriptorBindingSampledImageUpdateAfterBind);
6127     vn_encode_VkBool32(enc, &val->descriptorBindingStorageImageUpdateAfterBind);
6128     vn_encode_VkBool32(enc, &val->descriptorBindingStorageBufferUpdateAfterBind);
6129     vn_encode_VkBool32(enc, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
6130     vn_encode_VkBool32(enc, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
6131     vn_encode_VkBool32(enc, &val->descriptorBindingUpdateUnusedWhilePending);
6132     vn_encode_VkBool32(enc, &val->descriptorBindingPartiallyBound);
6133     vn_encode_VkBool32(enc, &val->descriptorBindingVariableDescriptorCount);
6134     vn_encode_VkBool32(enc, &val->runtimeDescriptorArray);
6135     vn_encode_VkBool32(enc, &val->samplerFilterMinmax);
6136     vn_encode_VkBool32(enc, &val->scalarBlockLayout);
6137     vn_encode_VkBool32(enc, &val->imagelessFramebuffer);
6138     vn_encode_VkBool32(enc, &val->uniformBufferStandardLayout);
6139     vn_encode_VkBool32(enc, &val->shaderSubgroupExtendedTypes);
6140     vn_encode_VkBool32(enc, &val->separateDepthStencilLayouts);
6141     vn_encode_VkBool32(enc, &val->hostQueryReset);
6142     vn_encode_VkBool32(enc, &val->timelineSemaphore);
6143     vn_encode_VkBool32(enc, &val->bufferDeviceAddress);
6144     vn_encode_VkBool32(enc, &val->bufferDeviceAddressCaptureReplay);
6145     vn_encode_VkBool32(enc, &val->bufferDeviceAddressMultiDevice);
6146     vn_encode_VkBool32(enc, &val->vulkanMemoryModel);
6147     vn_encode_VkBool32(enc, &val->vulkanMemoryModelDeviceScope);
6148     vn_encode_VkBool32(enc, &val->vulkanMemoryModelAvailabilityVisibilityChains);
6149     vn_encode_VkBool32(enc, &val->shaderOutputViewportIndex);
6150     vn_encode_VkBool32(enc, &val->shaderOutputLayer);
6151     vn_encode_VkBool32(enc, &val->subgroupBroadcastDynamicId);
6152 }
6153 
6154 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)6155 vn_encode_VkPhysicalDeviceVulkan12Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
6156 {
6157     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
6158     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
6159     vn_encode_VkPhysicalDeviceVulkan12Features_pnext(enc, val->pNext);
6160     vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, val);
6161 }
6162 
6163 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder * dec,const void * val)6164 vn_decode_VkPhysicalDeviceVulkan12Features_pnext(struct vn_cs_decoder *dec, const void *val)
6165 {
6166     /* no known/supported struct */
6167     if (vn_decode_simple_pointer(dec))
6168         assert(false);
6169 }
6170 
6171 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)6172 vn_decode_VkPhysicalDeviceVulkan12Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
6173 {
6174     /* skip val->{sType,pNext} */
6175     vn_decode_VkBool32(dec, &val->samplerMirrorClampToEdge);
6176     vn_decode_VkBool32(dec, &val->drawIndirectCount);
6177     vn_decode_VkBool32(dec, &val->storageBuffer8BitAccess);
6178     vn_decode_VkBool32(dec, &val->uniformAndStorageBuffer8BitAccess);
6179     vn_decode_VkBool32(dec, &val->storagePushConstant8);
6180     vn_decode_VkBool32(dec, &val->shaderBufferInt64Atomics);
6181     vn_decode_VkBool32(dec, &val->shaderSharedInt64Atomics);
6182     vn_decode_VkBool32(dec, &val->shaderFloat16);
6183     vn_decode_VkBool32(dec, &val->shaderInt8);
6184     vn_decode_VkBool32(dec, &val->descriptorIndexing);
6185     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayDynamicIndexing);
6186     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayDynamicIndexing);
6187     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayDynamicIndexing);
6188     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexing);
6189     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexing);
6190     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexing);
6191     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexing);
6192     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexing);
6193     vn_decode_VkBool32(dec, &val->shaderUniformTexelBufferArrayNonUniformIndexing);
6194     vn_decode_VkBool32(dec, &val->shaderStorageTexelBufferArrayNonUniformIndexing);
6195     vn_decode_VkBool32(dec, &val->descriptorBindingUniformBufferUpdateAfterBind);
6196     vn_decode_VkBool32(dec, &val->descriptorBindingSampledImageUpdateAfterBind);
6197     vn_decode_VkBool32(dec, &val->descriptorBindingStorageImageUpdateAfterBind);
6198     vn_decode_VkBool32(dec, &val->descriptorBindingStorageBufferUpdateAfterBind);
6199     vn_decode_VkBool32(dec, &val->descriptorBindingUniformTexelBufferUpdateAfterBind);
6200     vn_decode_VkBool32(dec, &val->descriptorBindingStorageTexelBufferUpdateAfterBind);
6201     vn_decode_VkBool32(dec, &val->descriptorBindingUpdateUnusedWhilePending);
6202     vn_decode_VkBool32(dec, &val->descriptorBindingPartiallyBound);
6203     vn_decode_VkBool32(dec, &val->descriptorBindingVariableDescriptorCount);
6204     vn_decode_VkBool32(dec, &val->runtimeDescriptorArray);
6205     vn_decode_VkBool32(dec, &val->samplerFilterMinmax);
6206     vn_decode_VkBool32(dec, &val->scalarBlockLayout);
6207     vn_decode_VkBool32(dec, &val->imagelessFramebuffer);
6208     vn_decode_VkBool32(dec, &val->uniformBufferStandardLayout);
6209     vn_decode_VkBool32(dec, &val->shaderSubgroupExtendedTypes);
6210     vn_decode_VkBool32(dec, &val->separateDepthStencilLayouts);
6211     vn_decode_VkBool32(dec, &val->hostQueryReset);
6212     vn_decode_VkBool32(dec, &val->timelineSemaphore);
6213     vn_decode_VkBool32(dec, &val->bufferDeviceAddress);
6214     vn_decode_VkBool32(dec, &val->bufferDeviceAddressCaptureReplay);
6215     vn_decode_VkBool32(dec, &val->bufferDeviceAddressMultiDevice);
6216     vn_decode_VkBool32(dec, &val->vulkanMemoryModel);
6217     vn_decode_VkBool32(dec, &val->vulkanMemoryModelDeviceScope);
6218     vn_decode_VkBool32(dec, &val->vulkanMemoryModelAvailabilityVisibilityChains);
6219     vn_decode_VkBool32(dec, &val->shaderOutputViewportIndex);
6220     vn_decode_VkBool32(dec, &val->shaderOutputLayer);
6221     vn_decode_VkBool32(dec, &val->subgroupBroadcastDynamicId);
6222 }
6223 
6224 static inline void
vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Features * val)6225 vn_decode_VkPhysicalDeviceVulkan12Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Features *val)
6226 {
6227     VkStructureType stype;
6228     vn_decode_VkStructureType(dec, &stype);
6229     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
6230 
6231     assert(val->sType == stype);
6232     vn_decode_VkPhysicalDeviceVulkan12Features_pnext(dec, val->pNext);
6233     vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, val);
6234 }
6235 
6236 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void * val)6237 vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(const void *val)
6238 {
6239     /* no known/supported struct */
6240     return vn_sizeof_simple_pointer(NULL);
6241 }
6242 
6243 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features * val)6244 vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(const VkPhysicalDeviceVulkan12Features *val)
6245 {
6246     size_t size = 0;
6247     /* skip val->{sType,pNext} */
6248     /* skip val->samplerMirrorClampToEdge */
6249     /* skip val->drawIndirectCount */
6250     /* skip val->storageBuffer8BitAccess */
6251     /* skip val->uniformAndStorageBuffer8BitAccess */
6252     /* skip val->storagePushConstant8 */
6253     /* skip val->shaderBufferInt64Atomics */
6254     /* skip val->shaderSharedInt64Atomics */
6255     /* skip val->shaderFloat16 */
6256     /* skip val->shaderInt8 */
6257     /* skip val->descriptorIndexing */
6258     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
6259     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
6260     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
6261     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
6262     /* skip val->shaderSampledImageArrayNonUniformIndexing */
6263     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
6264     /* skip val->shaderStorageImageArrayNonUniformIndexing */
6265     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
6266     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
6267     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
6268     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
6269     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
6270     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
6271     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
6272     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
6273     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
6274     /* skip val->descriptorBindingUpdateUnusedWhilePending */
6275     /* skip val->descriptorBindingPartiallyBound */
6276     /* skip val->descriptorBindingVariableDescriptorCount */
6277     /* skip val->runtimeDescriptorArray */
6278     /* skip val->samplerFilterMinmax */
6279     /* skip val->scalarBlockLayout */
6280     /* skip val->imagelessFramebuffer */
6281     /* skip val->uniformBufferStandardLayout */
6282     /* skip val->shaderSubgroupExtendedTypes */
6283     /* skip val->separateDepthStencilLayouts */
6284     /* skip val->hostQueryReset */
6285     /* skip val->timelineSemaphore */
6286     /* skip val->bufferDeviceAddress */
6287     /* skip val->bufferDeviceAddressCaptureReplay */
6288     /* skip val->bufferDeviceAddressMultiDevice */
6289     /* skip val->vulkanMemoryModel */
6290     /* skip val->vulkanMemoryModelDeviceScope */
6291     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
6292     /* skip val->shaderOutputViewportIndex */
6293     /* skip val->shaderOutputLayer */
6294     /* skip val->subgroupBroadcastDynamicId */
6295     return size;
6296 }
6297 
6298 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features * val)6299 vn_sizeof_VkPhysicalDeviceVulkan12Features_partial(const VkPhysicalDeviceVulkan12Features *val)
6300 {
6301     size_t size = 0;
6302 
6303     size += vn_sizeof_VkStructureType(&val->sType);
6304     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_pnext_partial(val->pNext);
6305     size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial(val);
6306 
6307     return size;
6308 }
6309 
6310 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)6311 vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6312 {
6313     /* no known/supported struct */
6314     vn_encode_simple_pointer(enc, NULL);
6315 }
6316 
6317 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)6318 vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
6319 {
6320     /* skip val->{sType,pNext} */
6321     /* skip val->samplerMirrorClampToEdge */
6322     /* skip val->drawIndirectCount */
6323     /* skip val->storageBuffer8BitAccess */
6324     /* skip val->uniformAndStorageBuffer8BitAccess */
6325     /* skip val->storagePushConstant8 */
6326     /* skip val->shaderBufferInt64Atomics */
6327     /* skip val->shaderSharedInt64Atomics */
6328     /* skip val->shaderFloat16 */
6329     /* skip val->shaderInt8 */
6330     /* skip val->descriptorIndexing */
6331     /* skip val->shaderInputAttachmentArrayDynamicIndexing */
6332     /* skip val->shaderUniformTexelBufferArrayDynamicIndexing */
6333     /* skip val->shaderStorageTexelBufferArrayDynamicIndexing */
6334     /* skip val->shaderUniformBufferArrayNonUniformIndexing */
6335     /* skip val->shaderSampledImageArrayNonUniformIndexing */
6336     /* skip val->shaderStorageBufferArrayNonUniformIndexing */
6337     /* skip val->shaderStorageImageArrayNonUniformIndexing */
6338     /* skip val->shaderInputAttachmentArrayNonUniformIndexing */
6339     /* skip val->shaderUniformTexelBufferArrayNonUniformIndexing */
6340     /* skip val->shaderStorageTexelBufferArrayNonUniformIndexing */
6341     /* skip val->descriptorBindingUniformBufferUpdateAfterBind */
6342     /* skip val->descriptorBindingSampledImageUpdateAfterBind */
6343     /* skip val->descriptorBindingStorageImageUpdateAfterBind */
6344     /* skip val->descriptorBindingStorageBufferUpdateAfterBind */
6345     /* skip val->descriptorBindingUniformTexelBufferUpdateAfterBind */
6346     /* skip val->descriptorBindingStorageTexelBufferUpdateAfterBind */
6347     /* skip val->descriptorBindingUpdateUnusedWhilePending */
6348     /* skip val->descriptorBindingPartiallyBound */
6349     /* skip val->descriptorBindingVariableDescriptorCount */
6350     /* skip val->runtimeDescriptorArray */
6351     /* skip val->samplerFilterMinmax */
6352     /* skip val->scalarBlockLayout */
6353     /* skip val->imagelessFramebuffer */
6354     /* skip val->uniformBufferStandardLayout */
6355     /* skip val->shaderSubgroupExtendedTypes */
6356     /* skip val->separateDepthStencilLayouts */
6357     /* skip val->hostQueryReset */
6358     /* skip val->timelineSemaphore */
6359     /* skip val->bufferDeviceAddress */
6360     /* skip val->bufferDeviceAddressCaptureReplay */
6361     /* skip val->bufferDeviceAddressMultiDevice */
6362     /* skip val->vulkanMemoryModel */
6363     /* skip val->vulkanMemoryModelDeviceScope */
6364     /* skip val->vulkanMemoryModelAvailabilityVisibilityChains */
6365     /* skip val->shaderOutputViewportIndex */
6366     /* skip val->shaderOutputLayer */
6367     /* skip val->subgroupBroadcastDynamicId */
6368 }
6369 
6370 static inline void
vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Features * val)6371 vn_encode_VkPhysicalDeviceVulkan12Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Features *val)
6372 {
6373     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
6374     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES });
6375     vn_encode_VkPhysicalDeviceVulkan12Features_pnext_partial(enc, val->pNext);
6376     vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, val);
6377 }
6378 
6379 /* struct VkPhysicalDeviceVulkan13Features chain */
6380 
6381 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(const void * val)6382 vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(const void *val)
6383 {
6384     /* no known/supported struct */
6385     return vn_sizeof_simple_pointer(NULL);
6386 }
6387 
6388 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_self(const VkPhysicalDeviceVulkan13Features * val)6389 vn_sizeof_VkPhysicalDeviceVulkan13Features_self(const VkPhysicalDeviceVulkan13Features *val)
6390 {
6391     size_t size = 0;
6392     /* skip val->{sType,pNext} */
6393     size += vn_sizeof_VkBool32(&val->robustImageAccess);
6394     size += vn_sizeof_VkBool32(&val->inlineUniformBlock);
6395     size += vn_sizeof_VkBool32(&val->descriptorBindingInlineUniformBlockUpdateAfterBind);
6396     size += vn_sizeof_VkBool32(&val->pipelineCreationCacheControl);
6397     size += vn_sizeof_VkBool32(&val->privateData);
6398     size += vn_sizeof_VkBool32(&val->shaderDemoteToHelperInvocation);
6399     size += vn_sizeof_VkBool32(&val->shaderTerminateInvocation);
6400     size += vn_sizeof_VkBool32(&val->subgroupSizeControl);
6401     size += vn_sizeof_VkBool32(&val->computeFullSubgroups);
6402     size += vn_sizeof_VkBool32(&val->synchronization2);
6403     size += vn_sizeof_VkBool32(&val->textureCompressionASTC_HDR);
6404     size += vn_sizeof_VkBool32(&val->shaderZeroInitializeWorkgroupMemory);
6405     size += vn_sizeof_VkBool32(&val->dynamicRendering);
6406     size += vn_sizeof_VkBool32(&val->shaderIntegerDotProduct);
6407     size += vn_sizeof_VkBool32(&val->maintenance4);
6408     return size;
6409 }
6410 
6411 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features * val)6412 vn_sizeof_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features *val)
6413 {
6414     size_t size = 0;
6415 
6416     size += vn_sizeof_VkStructureType(&val->sType);
6417     size += vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext(val->pNext);
6418     size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self(val);
6419 
6420     return size;
6421 }
6422 
6423 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_encoder * enc,const void * val)6424 vn_encode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_encoder *enc, const void *val)
6425 {
6426     /* no known/supported struct */
6427     vn_encode_simple_pointer(enc, NULL);
6428 }
6429 
6430 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)6431 vn_encode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
6432 {
6433     /* skip val->{sType,pNext} */
6434     vn_encode_VkBool32(enc, &val->robustImageAccess);
6435     vn_encode_VkBool32(enc, &val->inlineUniformBlock);
6436     vn_encode_VkBool32(enc, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
6437     vn_encode_VkBool32(enc, &val->pipelineCreationCacheControl);
6438     vn_encode_VkBool32(enc, &val->privateData);
6439     vn_encode_VkBool32(enc, &val->shaderDemoteToHelperInvocation);
6440     vn_encode_VkBool32(enc, &val->shaderTerminateInvocation);
6441     vn_encode_VkBool32(enc, &val->subgroupSizeControl);
6442     vn_encode_VkBool32(enc, &val->computeFullSubgroups);
6443     vn_encode_VkBool32(enc, &val->synchronization2);
6444     vn_encode_VkBool32(enc, &val->textureCompressionASTC_HDR);
6445     vn_encode_VkBool32(enc, &val->shaderZeroInitializeWorkgroupMemory);
6446     vn_encode_VkBool32(enc, &val->dynamicRendering);
6447     vn_encode_VkBool32(enc, &val->shaderIntegerDotProduct);
6448     vn_encode_VkBool32(enc, &val->maintenance4);
6449 }
6450 
6451 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)6452 vn_encode_VkPhysicalDeviceVulkan13Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
6453 {
6454     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
6455     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES });
6456     vn_encode_VkPhysicalDeviceVulkan13Features_pnext(enc, val->pNext);
6457     vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, val);
6458 }
6459 
6460 static inline void
vn_decode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_decoder * dec,const void * val)6461 vn_decode_VkPhysicalDeviceVulkan13Features_pnext(struct vn_cs_decoder *dec, const void *val)
6462 {
6463     /* no known/supported struct */
6464     if (vn_decode_simple_pointer(dec))
6465         assert(false);
6466 }
6467 
6468 static inline void
vn_decode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Features * val)6469 vn_decode_VkPhysicalDeviceVulkan13Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Features *val)
6470 {
6471     /* skip val->{sType,pNext} */
6472     vn_decode_VkBool32(dec, &val->robustImageAccess);
6473     vn_decode_VkBool32(dec, &val->inlineUniformBlock);
6474     vn_decode_VkBool32(dec, &val->descriptorBindingInlineUniformBlockUpdateAfterBind);
6475     vn_decode_VkBool32(dec, &val->pipelineCreationCacheControl);
6476     vn_decode_VkBool32(dec, &val->privateData);
6477     vn_decode_VkBool32(dec, &val->shaderDemoteToHelperInvocation);
6478     vn_decode_VkBool32(dec, &val->shaderTerminateInvocation);
6479     vn_decode_VkBool32(dec, &val->subgroupSizeControl);
6480     vn_decode_VkBool32(dec, &val->computeFullSubgroups);
6481     vn_decode_VkBool32(dec, &val->synchronization2);
6482     vn_decode_VkBool32(dec, &val->textureCompressionASTC_HDR);
6483     vn_decode_VkBool32(dec, &val->shaderZeroInitializeWorkgroupMemory);
6484     vn_decode_VkBool32(dec, &val->dynamicRendering);
6485     vn_decode_VkBool32(dec, &val->shaderIntegerDotProduct);
6486     vn_decode_VkBool32(dec, &val->maintenance4);
6487 }
6488 
6489 static inline void
vn_decode_VkPhysicalDeviceVulkan13Features(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Features * val)6490 vn_decode_VkPhysicalDeviceVulkan13Features(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Features *val)
6491 {
6492     VkStructureType stype;
6493     vn_decode_VkStructureType(dec, &stype);
6494     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
6495 
6496     assert(val->sType == stype);
6497     vn_decode_VkPhysicalDeviceVulkan13Features_pnext(dec, val->pNext);
6498     vn_decode_VkPhysicalDeviceVulkan13Features_self(dec, val);
6499 }
6500 
6501 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(const void * val)6502 vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(const void *val)
6503 {
6504     /* no known/supported struct */
6505     return vn_sizeof_simple_pointer(NULL);
6506 }
6507 
6508 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(const VkPhysicalDeviceVulkan13Features * val)6509 vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(const VkPhysicalDeviceVulkan13Features *val)
6510 {
6511     size_t size = 0;
6512     /* skip val->{sType,pNext} */
6513     /* skip val->robustImageAccess */
6514     /* skip val->inlineUniformBlock */
6515     /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
6516     /* skip val->pipelineCreationCacheControl */
6517     /* skip val->privateData */
6518     /* skip val->shaderDemoteToHelperInvocation */
6519     /* skip val->shaderTerminateInvocation */
6520     /* skip val->subgroupSizeControl */
6521     /* skip val->computeFullSubgroups */
6522     /* skip val->synchronization2 */
6523     /* skip val->textureCompressionASTC_HDR */
6524     /* skip val->shaderZeroInitializeWorkgroupMemory */
6525     /* skip val->dynamicRendering */
6526     /* skip val->shaderIntegerDotProduct */
6527     /* skip val->maintenance4 */
6528     return size;
6529 }
6530 
6531 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Features_partial(const VkPhysicalDeviceVulkan13Features * val)6532 vn_sizeof_VkPhysicalDeviceVulkan13Features_partial(const VkPhysicalDeviceVulkan13Features *val)
6533 {
6534     size_t size = 0;
6535 
6536     size += vn_sizeof_VkStructureType(&val->sType);
6537     size += vn_sizeof_VkPhysicalDeviceVulkan13Features_pnext_partial(val->pNext);
6538     size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial(val);
6539 
6540     return size;
6541 }
6542 
6543 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)6544 vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6545 {
6546     /* no known/supported struct */
6547     vn_encode_simple_pointer(enc, NULL);
6548 }
6549 
6550 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)6551 vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
6552 {
6553     /* skip val->{sType,pNext} */
6554     /* skip val->robustImageAccess */
6555     /* skip val->inlineUniformBlock */
6556     /* skip val->descriptorBindingInlineUniformBlockUpdateAfterBind */
6557     /* skip val->pipelineCreationCacheControl */
6558     /* skip val->privateData */
6559     /* skip val->shaderDemoteToHelperInvocation */
6560     /* skip val->shaderTerminateInvocation */
6561     /* skip val->subgroupSizeControl */
6562     /* skip val->computeFullSubgroups */
6563     /* skip val->synchronization2 */
6564     /* skip val->textureCompressionASTC_HDR */
6565     /* skip val->shaderZeroInitializeWorkgroupMemory */
6566     /* skip val->dynamicRendering */
6567     /* skip val->shaderIntegerDotProduct */
6568     /* skip val->maintenance4 */
6569 }
6570 
6571 static inline void
vn_encode_VkPhysicalDeviceVulkan13Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Features * val)6572 vn_encode_VkPhysicalDeviceVulkan13Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Features *val)
6573 {
6574     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
6575     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES });
6576     vn_encode_VkPhysicalDeviceVulkan13Features_pnext_partial(enc, val->pNext);
6577     vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(enc, val);
6578 }
6579 
6580 /* struct VkPhysicalDeviceCustomBorderColorFeaturesEXT chain */
6581 
6582 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(const void * val)6583 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(const void *val)
6584 {
6585     /* no known/supported struct */
6586     return vn_sizeof_simple_pointer(NULL);
6587 }
6588 
6589 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6590 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6591 {
6592     size_t size = 0;
6593     /* skip val->{sType,pNext} */
6594     size += vn_sizeof_VkBool32(&val->customBorderColors);
6595     size += vn_sizeof_VkBool32(&val->customBorderColorWithoutFormat);
6596     return size;
6597 }
6598 
6599 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6600 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6601 {
6602     size_t size = 0;
6603 
6604     size += vn_sizeof_VkStructureType(&val->sType);
6605     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(val->pNext);
6606     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(val);
6607 
6608     return size;
6609 }
6610 
6611 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)6612 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
6613 {
6614     /* no known/supported struct */
6615     vn_encode_simple_pointer(enc, NULL);
6616 }
6617 
6618 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6619 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6620 {
6621     /* skip val->{sType,pNext} */
6622     vn_encode_VkBool32(enc, &val->customBorderColors);
6623     vn_encode_VkBool32(enc, &val->customBorderColorWithoutFormat);
6624 }
6625 
6626 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6627 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6628 {
6629     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
6630     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT });
6631     vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(enc, val->pNext);
6632     vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(enc, val);
6633 }
6634 
6635 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)6636 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
6637 {
6638     /* no known/supported struct */
6639     if (vn_decode_simple_pointer(dec))
6640         assert(false);
6641 }
6642 
6643 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6644 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6645 {
6646     /* skip val->{sType,pNext} */
6647     vn_decode_VkBool32(dec, &val->customBorderColors);
6648     vn_decode_VkBool32(dec, &val->customBorderColorWithoutFormat);
6649 }
6650 
6651 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6652 vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6653 {
6654     VkStructureType stype;
6655     vn_decode_VkStructureType(dec, &stype);
6656     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
6657 
6658     assert(val->sType == stype);
6659     vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext(dec, val->pNext);
6660     vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(dec, val);
6661 }
6662 
6663 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(const void * val)6664 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(const void *val)
6665 {
6666     /* no known/supported struct */
6667     return vn_sizeof_simple_pointer(NULL);
6668 }
6669 
6670 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6671 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6672 {
6673     size_t size = 0;
6674     /* skip val->{sType,pNext} */
6675     /* skip val->customBorderColors */
6676     /* skip val->customBorderColorWithoutFormat */
6677     return size;
6678 }
6679 
6680 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6681 vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6682 {
6683     size_t size = 0;
6684 
6685     size += vn_sizeof_VkStructureType(&val->sType);
6686     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(val->pNext);
6687     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(val);
6688 
6689     return size;
6690 }
6691 
6692 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)6693 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6694 {
6695     /* no known/supported struct */
6696     vn_encode_simple_pointer(enc, NULL);
6697 }
6698 
6699 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6700 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6701 {
6702     /* skip val->{sType,pNext} */
6703     /* skip val->customBorderColors */
6704     /* skip val->customBorderColorWithoutFormat */
6705 }
6706 
6707 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorFeaturesEXT * val)6708 vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *val)
6709 {
6710     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
6711     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT });
6712     vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_pnext_partial(enc, val->pNext);
6713     vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(enc, val);
6714 }
6715 
6716 /* struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT chain */
6717 
6718 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(const void * val)6719 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(const void *val)
6720 {
6721     /* no known/supported struct */
6722     return vn_sizeof_simple_pointer(NULL);
6723 }
6724 
6725 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6726 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6727 {
6728     size_t size = 0;
6729     /* skip val->{sType,pNext} */
6730     size += vn_sizeof_VkBool32(&val->extendedDynamicState);
6731     return size;
6732 }
6733 
6734 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6735 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6736 {
6737     size_t size = 0;
6738 
6739     size += vn_sizeof_VkStructureType(&val->sType);
6740     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(val->pNext);
6741     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(val);
6742 
6743     return size;
6744 }
6745 
6746 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)6747 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
6748 {
6749     /* no known/supported struct */
6750     vn_encode_simple_pointer(enc, NULL);
6751 }
6752 
6753 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6754 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6755 {
6756     /* skip val->{sType,pNext} */
6757     vn_encode_VkBool32(enc, &val->extendedDynamicState);
6758 }
6759 
6760 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6761 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6762 {
6763     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
6764     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT });
6765     vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(enc, val->pNext);
6766     vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, val);
6767 }
6768 
6769 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)6770 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
6771 {
6772     /* no known/supported struct */
6773     if (vn_decode_simple_pointer(dec))
6774         assert(false);
6775 }
6776 
6777 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6778 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6779 {
6780     /* skip val->{sType,pNext} */
6781     vn_decode_VkBool32(dec, &val->extendedDynamicState);
6782 }
6783 
6784 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6785 vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6786 {
6787     VkStructureType stype;
6788     vn_decode_VkStructureType(dec, &stype);
6789     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
6790 
6791     assert(val->sType == stype);
6792     vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext(dec, val->pNext);
6793     vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(dec, val);
6794 }
6795 
6796 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(const void * val)6797 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(const void *val)
6798 {
6799     /* no known/supported struct */
6800     return vn_sizeof_simple_pointer(NULL);
6801 }
6802 
6803 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6804 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6805 {
6806     size_t size = 0;
6807     /* skip val->{sType,pNext} */
6808     /* skip val->extendedDynamicState */
6809     return size;
6810 }
6811 
6812 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6813 vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6814 {
6815     size_t size = 0;
6816 
6817     size += vn_sizeof_VkStructureType(&val->sType);
6818     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(val->pNext);
6819     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(val);
6820 
6821     return size;
6822 }
6823 
6824 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)6825 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6826 {
6827     /* no known/supported struct */
6828     vn_encode_simple_pointer(enc, NULL);
6829 }
6830 
6831 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6832 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6833 {
6834     /* skip val->{sType,pNext} */
6835     /* skip val->extendedDynamicState */
6836 }
6837 
6838 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT * val)6839 vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *val)
6840 {
6841     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
6842     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT });
6843     vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_pnext_partial(enc, val->pNext);
6844     vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(enc, val);
6845 }
6846 
6847 /* struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT chain */
6848 
6849 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(const void * val)6850 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(const void *val)
6851 {
6852     /* no known/supported struct */
6853     return vn_sizeof_simple_pointer(NULL);
6854 }
6855 
6856 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6857 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6858 {
6859     size_t size = 0;
6860     /* skip val->{sType,pNext} */
6861     size += vn_sizeof_VkBool32(&val->extendedDynamicState2);
6862     size += vn_sizeof_VkBool32(&val->extendedDynamicState2LogicOp);
6863     size += vn_sizeof_VkBool32(&val->extendedDynamicState2PatchControlPoints);
6864     return size;
6865 }
6866 
6867 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6868 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6869 {
6870     size_t size = 0;
6871 
6872     size += vn_sizeof_VkStructureType(&val->sType);
6873     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(val->pNext);
6874     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(val);
6875 
6876     return size;
6877 }
6878 
6879 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)6880 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
6881 {
6882     /* no known/supported struct */
6883     vn_encode_simple_pointer(enc, NULL);
6884 }
6885 
6886 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6887 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6888 {
6889     /* skip val->{sType,pNext} */
6890     vn_encode_VkBool32(enc, &val->extendedDynamicState2);
6891     vn_encode_VkBool32(enc, &val->extendedDynamicState2LogicOp);
6892     vn_encode_VkBool32(enc, &val->extendedDynamicState2PatchControlPoints);
6893 }
6894 
6895 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6896 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6897 {
6898     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
6899     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT });
6900     vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(enc, val->pNext);
6901     vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, val);
6902 }
6903 
6904 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)6905 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
6906 {
6907     /* no known/supported struct */
6908     if (vn_decode_simple_pointer(dec))
6909         assert(false);
6910 }
6911 
6912 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6913 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6914 {
6915     /* skip val->{sType,pNext} */
6916     vn_decode_VkBool32(dec, &val->extendedDynamicState2);
6917     vn_decode_VkBool32(dec, &val->extendedDynamicState2LogicOp);
6918     vn_decode_VkBool32(dec, &val->extendedDynamicState2PatchControlPoints);
6919 }
6920 
6921 static inline void
vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6922 vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6923 {
6924     VkStructureType stype;
6925     vn_decode_VkStructureType(dec, &stype);
6926     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
6927 
6928     assert(val->sType == stype);
6929     vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext(dec, val->pNext);
6930     vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(dec, val);
6931 }
6932 
6933 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(const void * val)6934 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(const void *val)
6935 {
6936     /* no known/supported struct */
6937     return vn_sizeof_simple_pointer(NULL);
6938 }
6939 
6940 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6941 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6942 {
6943     size_t size = 0;
6944     /* skip val->{sType,pNext} */
6945     /* skip val->extendedDynamicState2 */
6946     /* skip val->extendedDynamicState2LogicOp */
6947     /* skip val->extendedDynamicState2PatchControlPoints */
6948     return size;
6949 }
6950 
6951 static inline size_t
vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6952 vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6953 {
6954     size_t size = 0;
6955 
6956     size += vn_sizeof_VkStructureType(&val->sType);
6957     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(val->pNext);
6958     size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(val);
6959 
6960     return size;
6961 }
6962 
6963 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)6964 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
6965 {
6966     /* no known/supported struct */
6967     vn_encode_simple_pointer(enc, NULL);
6968 }
6969 
6970 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6971 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6972 {
6973     /* skip val->{sType,pNext} */
6974     /* skip val->extendedDynamicState2 */
6975     /* skip val->extendedDynamicState2LogicOp */
6976     /* skip val->extendedDynamicState2PatchControlPoints */
6977 }
6978 
6979 static inline void
vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT * val)6980 vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *val)
6981 {
6982     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
6983     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT });
6984     vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_pnext_partial(enc, val->pNext);
6985     vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(enc, val);
6986 }
6987 
6988 /* struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures chain */
6989 
6990 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(const void * val)6991 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(const void *val)
6992 {
6993     /* no known/supported struct */
6994     return vn_sizeof_simple_pointer(NULL);
6995 }
6996 
6997 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)6998 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
6999 {
7000     size_t size = 0;
7001     /* skip val->{sType,pNext} */
7002     size += vn_sizeof_VkBool32(&val->shaderZeroInitializeWorkgroupMemory);
7003     return size;
7004 }
7005 
7006 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7007 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7008 {
7009     size_t size = 0;
7010 
7011     size += vn_sizeof_VkStructureType(&val->sType);
7012     size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(val->pNext);
7013     size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(val);
7014 
7015     return size;
7016 }
7017 
7018 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_encoder * enc,const void * val)7019 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
7020 {
7021     /* no known/supported struct */
7022     vn_encode_simple_pointer(enc, NULL);
7023 }
7024 
7025 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7026 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7027 {
7028     /* skip val->{sType,pNext} */
7029     vn_encode_VkBool32(enc, &val->shaderZeroInitializeWorkgroupMemory);
7030 }
7031 
7032 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7033 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7034 {
7035     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
7036     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES });
7037     vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(enc, val->pNext);
7038     vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, val);
7039 }
7040 
7041 static inline void
vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_decoder * dec,const void * val)7042 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
7043 {
7044     /* no known/supported struct */
7045     if (vn_decode_simple_pointer(dec))
7046         assert(false);
7047 }
7048 
7049 static inline void
vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7050 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7051 {
7052     /* skip val->{sType,pNext} */
7053     vn_decode_VkBool32(dec, &val->shaderZeroInitializeWorkgroupMemory);
7054 }
7055 
7056 static inline void
vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7057 vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7058 {
7059     VkStructureType stype;
7060     vn_decode_VkStructureType(dec, &stype);
7061     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
7062 
7063     assert(val->sType == stype);
7064     vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext(dec, val->pNext);
7065     vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(dec, val);
7066 }
7067 
7068 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(const void * val)7069 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(const void *val)
7070 {
7071     /* no known/supported struct */
7072     return vn_sizeof_simple_pointer(NULL);
7073 }
7074 
7075 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7076 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7077 {
7078     size_t size = 0;
7079     /* skip val->{sType,pNext} */
7080     /* skip val->shaderZeroInitializeWorkgroupMemory */
7081     return size;
7082 }
7083 
7084 static inline size_t
vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7085 vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7086 {
7087     size_t size = 0;
7088 
7089     size += vn_sizeof_VkStructureType(&val->sType);
7090     size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(val->pNext);
7091     size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(val);
7092 
7093     return size;
7094 }
7095 
7096 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)7097 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7098 {
7099     /* no known/supported struct */
7100     vn_encode_simple_pointer(enc, NULL);
7101 }
7102 
7103 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7104 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7105 {
7106     /* skip val->{sType,pNext} */
7107     /* skip val->shaderZeroInitializeWorkgroupMemory */
7108 }
7109 
7110 static inline void
vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures * val)7111 vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *val)
7112 {
7113     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
7114     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES });
7115     vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_pnext_partial(enc, val->pNext);
7116     vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(enc, val);
7117 }
7118 
7119 /* struct VkPhysicalDeviceRobustness2FeaturesEXT chain */
7120 
7121 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(const void * val)7122 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(const void *val)
7123 {
7124     /* no known/supported struct */
7125     return vn_sizeof_simple_pointer(NULL);
7126 }
7127 
7128 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self(const VkPhysicalDeviceRobustness2FeaturesEXT * val)7129 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7130 {
7131     size_t size = 0;
7132     /* skip val->{sType,pNext} */
7133     size += vn_sizeof_VkBool32(&val->robustBufferAccess2);
7134     size += vn_sizeof_VkBool32(&val->robustImageAccess2);
7135     size += vn_sizeof_VkBool32(&val->nullDescriptor);
7136     return size;
7137 }
7138 
7139 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT * val)7140 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7141 {
7142     size_t size = 0;
7143 
7144     size += vn_sizeof_VkStructureType(&val->sType);
7145     size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(val->pNext);
7146     size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self(val);
7147 
7148     return size;
7149 }
7150 
7151 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7152 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
7153 {
7154     /* no known/supported struct */
7155     vn_encode_simple_pointer(enc, NULL);
7156 }
7157 
7158 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)7159 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7160 {
7161     /* skip val->{sType,pNext} */
7162     vn_encode_VkBool32(enc, &val->robustBufferAccess2);
7163     vn_encode_VkBool32(enc, &val->robustImageAccess2);
7164     vn_encode_VkBool32(enc, &val->nullDescriptor);
7165 }
7166 
7167 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)7168 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7169 {
7170     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
7171     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT });
7172     vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(enc, val->pNext);
7173     vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(enc, val);
7174 }
7175 
7176 static inline void
vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7177 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7178 {
7179     /* no known/supported struct */
7180     if (vn_decode_simple_pointer(dec))
7181         assert(false);
7182 }
7183 
7184 static inline void
vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2FeaturesEXT * val)7185 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2FeaturesEXT *val)
7186 {
7187     /* skip val->{sType,pNext} */
7188     vn_decode_VkBool32(dec, &val->robustBufferAccess2);
7189     vn_decode_VkBool32(dec, &val->robustImageAccess2);
7190     vn_decode_VkBool32(dec, &val->nullDescriptor);
7191 }
7192 
7193 static inline void
vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2FeaturesEXT * val)7194 vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2FeaturesEXT *val)
7195 {
7196     VkStructureType stype;
7197     vn_decode_VkStructureType(dec, &stype);
7198     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
7199 
7200     assert(val->sType == stype);
7201     vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext(dec, val->pNext);
7202     vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(dec, val);
7203 }
7204 
7205 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(const void * val)7206 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(const void *val)
7207 {
7208     /* no known/supported struct */
7209     return vn_sizeof_simple_pointer(NULL);
7210 }
7211 
7212 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(const VkPhysicalDeviceRobustness2FeaturesEXT * val)7213 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7214 {
7215     size_t size = 0;
7216     /* skip val->{sType,pNext} */
7217     /* skip val->robustBufferAccess2 */
7218     /* skip val->robustImageAccess2 */
7219     /* skip val->nullDescriptor */
7220     return size;
7221 }
7222 
7223 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_partial(const VkPhysicalDeviceRobustness2FeaturesEXT * val)7224 vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_partial(const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7225 {
7226     size_t size = 0;
7227 
7228     size += vn_sizeof_VkStructureType(&val->sType);
7229     size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(val->pNext);
7230     size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(val);
7231 
7232     return size;
7233 }
7234 
7235 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7236 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7237 {
7238     /* no known/supported struct */
7239     vn_encode_simple_pointer(enc, NULL);
7240 }
7241 
7242 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)7243 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7244 {
7245     /* skip val->{sType,pNext} */
7246     /* skip val->robustBufferAccess2 */
7247     /* skip val->robustImageAccess2 */
7248     /* skip val->nullDescriptor */
7249 }
7250 
7251 static inline void
vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2FeaturesEXT * val)7252 vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2FeaturesEXT *val)
7253 {
7254     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
7255     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT });
7256     vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_pnext_partial(enc, val->pNext);
7257     vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(enc, val);
7258 }
7259 
7260 /* struct VkPhysicalDeviceImageRobustnessFeatures chain */
7261 
7262 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(const void * val)7263 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(const void *val)
7264 {
7265     /* no known/supported struct */
7266     return vn_sizeof_simple_pointer(NULL);
7267 }
7268 
7269 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(const VkPhysicalDeviceImageRobustnessFeatures * val)7270 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(const VkPhysicalDeviceImageRobustnessFeatures *val)
7271 {
7272     size_t size = 0;
7273     /* skip val->{sType,pNext} */
7274     size += vn_sizeof_VkBool32(&val->robustImageAccess);
7275     return size;
7276 }
7277 
7278 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures * val)7279 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures *val)
7280 {
7281     size_t size = 0;
7282 
7283     size += vn_sizeof_VkStructureType(&val->sType);
7284     size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext(val->pNext);
7285     size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self(val);
7286 
7287     return size;
7288 }
7289 
7290 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_encoder * enc,const void * val)7291 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
7292 {
7293     /* no known/supported struct */
7294     vn_encode_simple_pointer(enc, NULL);
7295 }
7296 
7297 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)7298 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
7299 {
7300     /* skip val->{sType,pNext} */
7301     vn_encode_VkBool32(enc, &val->robustImageAccess);
7302 }
7303 
7304 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)7305 vn_encode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
7306 {
7307     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
7308     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES });
7309     vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext(enc, val->pNext);
7310     vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, val);
7311 }
7312 
7313 static inline void
vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_decoder * dec,const void * val)7314 vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
7315 {
7316     /* no known/supported struct */
7317     if (vn_decode_simple_pointer(dec))
7318         assert(false);
7319 }
7320 
7321 static inline void
vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImageRobustnessFeatures * val)7322 vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImageRobustnessFeatures *val)
7323 {
7324     /* skip val->{sType,pNext} */
7325     vn_decode_VkBool32(dec, &val->robustImageAccess);
7326 }
7327 
7328 static inline void
vn_decode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceImageRobustnessFeatures * val)7329 vn_decode_VkPhysicalDeviceImageRobustnessFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceImageRobustnessFeatures *val)
7330 {
7331     VkStructureType stype;
7332     vn_decode_VkStructureType(dec, &stype);
7333     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
7334 
7335     assert(val->sType == stype);
7336     vn_decode_VkPhysicalDeviceImageRobustnessFeatures_pnext(dec, val->pNext);
7337     vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(dec, val);
7338 }
7339 
7340 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(const void * val)7341 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(const void *val)
7342 {
7343     /* no known/supported struct */
7344     return vn_sizeof_simple_pointer(NULL);
7345 }
7346 
7347 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(const VkPhysicalDeviceImageRobustnessFeatures * val)7348 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(const VkPhysicalDeviceImageRobustnessFeatures *val)
7349 {
7350     size_t size = 0;
7351     /* skip val->{sType,pNext} */
7352     /* skip val->robustImageAccess */
7353     return size;
7354 }
7355 
7356 static inline size_t
vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_partial(const VkPhysicalDeviceImageRobustnessFeatures * val)7357 vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_partial(const VkPhysicalDeviceImageRobustnessFeatures *val)
7358 {
7359     size_t size = 0;
7360 
7361     size += vn_sizeof_VkStructureType(&val->sType);
7362     size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(val->pNext);
7363     size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial(val);
7364 
7365     return size;
7366 }
7367 
7368 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)7369 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7370 {
7371     /* no known/supported struct */
7372     vn_encode_simple_pointer(enc, NULL);
7373 }
7374 
7375 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)7376 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
7377 {
7378     /* skip val->{sType,pNext} */
7379     /* skip val->robustImageAccess */
7380 }
7381 
7382 static inline void
vn_encode_VkPhysicalDeviceImageRobustnessFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageRobustnessFeatures * val)7383 vn_encode_VkPhysicalDeviceImageRobustnessFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageRobustnessFeatures *val)
7384 {
7385     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
7386     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES });
7387     vn_encode_VkPhysicalDeviceImageRobustnessFeatures_pnext_partial(enc, val->pNext);
7388     vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(enc, val);
7389 }
7390 
7391 /* struct VkPhysicalDevice4444FormatsFeaturesEXT chain */
7392 
7393 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(const void * val)7394 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(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_VkPhysicalDevice4444FormatsFeaturesEXT_self(const VkPhysicalDevice4444FormatsFeaturesEXT * val)7401 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7402 {
7403     size_t size = 0;
7404     /* skip val->{sType,pNext} */
7405     size += vn_sizeof_VkBool32(&val->formatA4R4G4B4);
7406     size += vn_sizeof_VkBool32(&val->formatA4B4G4R4);
7407     return size;
7408 }
7409 
7410 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT * val)7411 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7412 {
7413     size_t size = 0;
7414 
7415     size += vn_sizeof_VkStructureType(&val->sType);
7416     size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(val->pNext);
7417     size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self(val);
7418 
7419     return size;
7420 }
7421 
7422 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7423 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
7424 {
7425     /* no known/supported struct */
7426     vn_encode_simple_pointer(enc, NULL);
7427 }
7428 
7429 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)7430 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7431 {
7432     /* skip val->{sType,pNext} */
7433     vn_encode_VkBool32(enc, &val->formatA4R4G4B4);
7434     vn_encode_VkBool32(enc, &val->formatA4B4G4R4);
7435 }
7436 
7437 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)7438 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7439 {
7440     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
7441     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT });
7442     vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(enc, val->pNext);
7443     vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, val);
7444 }
7445 
7446 static inline void
vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7447 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7448 {
7449     /* no known/supported struct */
7450     if (vn_decode_simple_pointer(dec))
7451         assert(false);
7452 }
7453 
7454 static inline void
vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDevice4444FormatsFeaturesEXT * val)7455 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDevice4444FormatsFeaturesEXT *val)
7456 {
7457     /* skip val->{sType,pNext} */
7458     vn_decode_VkBool32(dec, &val->formatA4R4G4B4);
7459     vn_decode_VkBool32(dec, &val->formatA4B4G4R4);
7460 }
7461 
7462 static inline void
vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDevice4444FormatsFeaturesEXT * val)7463 vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDevice4444FormatsFeaturesEXT *val)
7464 {
7465     VkStructureType stype;
7466     vn_decode_VkStructureType(dec, &stype);
7467     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
7468 
7469     assert(val->sType == stype);
7470     vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext(dec, val->pNext);
7471     vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(dec, val);
7472 }
7473 
7474 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(const void * val)7475 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(const void *val)
7476 {
7477     /* no known/supported struct */
7478     return vn_sizeof_simple_pointer(NULL);
7479 }
7480 
7481 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(const VkPhysicalDevice4444FormatsFeaturesEXT * val)7482 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7483 {
7484     size_t size = 0;
7485     /* skip val->{sType,pNext} */
7486     /* skip val->formatA4R4G4B4 */
7487     /* skip val->formatA4B4G4R4 */
7488     return size;
7489 }
7490 
7491 static inline size_t
vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_partial(const VkPhysicalDevice4444FormatsFeaturesEXT * val)7492 vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_partial(const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7493 {
7494     size_t size = 0;
7495 
7496     size += vn_sizeof_VkStructureType(&val->sType);
7497     size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(val->pNext);
7498     size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(val);
7499 
7500     return size;
7501 }
7502 
7503 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7504 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7505 {
7506     /* no known/supported struct */
7507     vn_encode_simple_pointer(enc, NULL);
7508 }
7509 
7510 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)7511 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7512 {
7513     /* skip val->{sType,pNext} */
7514     /* skip val->formatA4R4G4B4 */
7515     /* skip val->formatA4B4G4R4 */
7516 }
7517 
7518 static inline void
vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDevice4444FormatsFeaturesEXT * val)7519 vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDevice4444FormatsFeaturesEXT *val)
7520 {
7521     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
7522     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT });
7523     vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_pnext_partial(enc, val->pNext);
7524     vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(enc, val);
7525 }
7526 
7527 /* struct VkPhysicalDeviceShaderTerminateInvocationFeatures chain */
7528 
7529 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(const void * val)7530 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(const void *val)
7531 {
7532     /* no known/supported struct */
7533     return vn_sizeof_simple_pointer(NULL);
7534 }
7535 
7536 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7537 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7538 {
7539     size_t size = 0;
7540     /* skip val->{sType,pNext} */
7541     size += vn_sizeof_VkBool32(&val->shaderTerminateInvocation);
7542     return size;
7543 }
7544 
7545 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7546 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7547 {
7548     size_t size = 0;
7549 
7550     size += vn_sizeof_VkStructureType(&val->sType);
7551     size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(val->pNext);
7552     size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(val);
7553 
7554     return size;
7555 }
7556 
7557 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_encoder * enc,const void * val)7558 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
7559 {
7560     /* no known/supported struct */
7561     vn_encode_simple_pointer(enc, NULL);
7562 }
7563 
7564 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7565 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7566 {
7567     /* skip val->{sType,pNext} */
7568     vn_encode_VkBool32(enc, &val->shaderTerminateInvocation);
7569 }
7570 
7571 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7572 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7573 {
7574     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
7575     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES });
7576     vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(enc, val->pNext);
7577     vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, val);
7578 }
7579 
7580 static inline void
vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_decoder * dec,const void * val)7581 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
7582 {
7583     /* no known/supported struct */
7584     if (vn_decode_simple_pointer(dec))
7585         assert(false);
7586 }
7587 
7588 static inline void
vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7589 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7590 {
7591     /* skip val->{sType,pNext} */
7592     vn_decode_VkBool32(dec, &val->shaderTerminateInvocation);
7593 }
7594 
7595 static inline void
vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7596 vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7597 {
7598     VkStructureType stype;
7599     vn_decode_VkStructureType(dec, &stype);
7600     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
7601 
7602     assert(val->sType == stype);
7603     vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext(dec, val->pNext);
7604     vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(dec, val);
7605 }
7606 
7607 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(const void * val)7608 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(const void *val)
7609 {
7610     /* no known/supported struct */
7611     return vn_sizeof_simple_pointer(NULL);
7612 }
7613 
7614 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7615 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7616 {
7617     size_t size = 0;
7618     /* skip val->{sType,pNext} */
7619     /* skip val->shaderTerminateInvocation */
7620     return size;
7621 }
7622 
7623 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7624 vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7625 {
7626     size_t size = 0;
7627 
7628     size += vn_sizeof_VkStructureType(&val->sType);
7629     size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(val->pNext);
7630     size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(val);
7631 
7632     return size;
7633 }
7634 
7635 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)7636 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7637 {
7638     /* no known/supported struct */
7639     vn_encode_simple_pointer(enc, NULL);
7640 }
7641 
7642 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7643 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7644 {
7645     /* skip val->{sType,pNext} */
7646     /* skip val->shaderTerminateInvocation */
7647 }
7648 
7649 static inline void
vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderTerminateInvocationFeatures * val)7650 vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderTerminateInvocationFeatures *val)
7651 {
7652     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
7653     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES });
7654     vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_pnext_partial(enc, val->pNext);
7655     vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(enc, val);
7656 }
7657 
7658 /* struct VkPhysicalDeviceSynchronization2Features chain */
7659 
7660 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(const void * val)7661 vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(const void *val)
7662 {
7663     /* no known/supported struct */
7664     return vn_sizeof_simple_pointer(NULL);
7665 }
7666 
7667 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(const VkPhysicalDeviceSynchronization2Features * val)7668 vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(const VkPhysicalDeviceSynchronization2Features *val)
7669 {
7670     size_t size = 0;
7671     /* skip val->{sType,pNext} */
7672     size += vn_sizeof_VkBool32(&val->synchronization2);
7673     return size;
7674 }
7675 
7676 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features * val)7677 vn_sizeof_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features *val)
7678 {
7679     size_t size = 0;
7680 
7681     size += vn_sizeof_VkStructureType(&val->sType);
7682     size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext(val->pNext);
7683     size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self(val);
7684 
7685     return size;
7686 }
7687 
7688 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_encoder * enc,const void * val)7689 vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_encoder *enc, const void *val)
7690 {
7691     /* no known/supported struct */
7692     vn_encode_simple_pointer(enc, NULL);
7693 }
7694 
7695 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)7696 vn_encode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
7697 {
7698     /* skip val->{sType,pNext} */
7699     vn_encode_VkBool32(enc, &val->synchronization2);
7700 }
7701 
7702 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)7703 vn_encode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
7704 {
7705     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
7706     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES });
7707     vn_encode_VkPhysicalDeviceSynchronization2Features_pnext(enc, val->pNext);
7708     vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, val);
7709 }
7710 
7711 static inline void
vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_decoder * dec,const void * val)7712 vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(struct vn_cs_decoder *dec, const void *val)
7713 {
7714     /* no known/supported struct */
7715     if (vn_decode_simple_pointer(dec))
7716         assert(false);
7717 }
7718 
7719 static inline void
vn_decode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSynchronization2Features * val)7720 vn_decode_VkPhysicalDeviceSynchronization2Features_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSynchronization2Features *val)
7721 {
7722     /* skip val->{sType,pNext} */
7723     vn_decode_VkBool32(dec, &val->synchronization2);
7724 }
7725 
7726 static inline void
vn_decode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_decoder * dec,VkPhysicalDeviceSynchronization2Features * val)7727 vn_decode_VkPhysicalDeviceSynchronization2Features(struct vn_cs_decoder *dec, VkPhysicalDeviceSynchronization2Features *val)
7728 {
7729     VkStructureType stype;
7730     vn_decode_VkStructureType(dec, &stype);
7731     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
7732 
7733     assert(val->sType == stype);
7734     vn_decode_VkPhysicalDeviceSynchronization2Features_pnext(dec, val->pNext);
7735     vn_decode_VkPhysicalDeviceSynchronization2Features_self(dec, val);
7736 }
7737 
7738 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(const void * val)7739 vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(const void *val)
7740 {
7741     /* no known/supported struct */
7742     return vn_sizeof_simple_pointer(NULL);
7743 }
7744 
7745 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(const VkPhysicalDeviceSynchronization2Features * val)7746 vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(const VkPhysicalDeviceSynchronization2Features *val)
7747 {
7748     size_t size = 0;
7749     /* skip val->{sType,pNext} */
7750     /* skip val->synchronization2 */
7751     return size;
7752 }
7753 
7754 static inline size_t
vn_sizeof_VkPhysicalDeviceSynchronization2Features_partial(const VkPhysicalDeviceSynchronization2Features * val)7755 vn_sizeof_VkPhysicalDeviceSynchronization2Features_partial(const VkPhysicalDeviceSynchronization2Features *val)
7756 {
7757     size_t size = 0;
7758 
7759     size += vn_sizeof_VkStructureType(&val->sType);
7760     size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_pnext_partial(val->pNext);
7761     size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial(val);
7762 
7763     return size;
7764 }
7765 
7766 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(struct vn_cs_encoder * enc,const void * val)7767 vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7768 {
7769     /* no known/supported struct */
7770     vn_encode_simple_pointer(enc, NULL);
7771 }
7772 
7773 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)7774 vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
7775 {
7776     /* skip val->{sType,pNext} */
7777     /* skip val->synchronization2 */
7778 }
7779 
7780 static inline void
vn_encode_VkPhysicalDeviceSynchronization2Features_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSynchronization2Features * val)7781 vn_encode_VkPhysicalDeviceSynchronization2Features_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSynchronization2Features *val)
7782 {
7783     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
7784     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES });
7785     vn_encode_VkPhysicalDeviceSynchronization2Features_pnext_partial(enc, val->pNext);
7786     vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(enc, val);
7787 }
7788 
7789 /* struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT chain */
7790 
7791 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(const void * val)7792 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(const void *val)
7793 {
7794     /* no known/supported struct */
7795     return vn_sizeof_simple_pointer(NULL);
7796 }
7797 
7798 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7799 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7800 {
7801     size_t size = 0;
7802     /* skip val->{sType,pNext} */
7803     size += vn_sizeof_VkBool32(&val->ycbcr2plane444Formats);
7804     return size;
7805 }
7806 
7807 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7808 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7809 {
7810     size_t size = 0;
7811 
7812     size += vn_sizeof_VkStructureType(&val->sType);
7813     size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(val->pNext);
7814     size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(val);
7815 
7816     return size;
7817 }
7818 
7819 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7820 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
7821 {
7822     /* no known/supported struct */
7823     vn_encode_simple_pointer(enc, NULL);
7824 }
7825 
7826 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7827 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7828 {
7829     /* skip val->{sType,pNext} */
7830     vn_encode_VkBool32(enc, &val->ycbcr2plane444Formats);
7831 }
7832 
7833 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7834 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7835 {
7836     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
7837     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT });
7838     vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(enc, val->pNext);
7839     vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, val);
7840 }
7841 
7842 static inline void
vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7843 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7844 {
7845     /* no known/supported struct */
7846     if (vn_decode_simple_pointer(dec))
7847         assert(false);
7848 }
7849 
7850 static inline void
vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7851 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7852 {
7853     /* skip val->{sType,pNext} */
7854     vn_decode_VkBool32(dec, &val->ycbcr2plane444Formats);
7855 }
7856 
7857 static inline void
vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7858 vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7859 {
7860     VkStructureType stype;
7861     vn_decode_VkStructureType(dec, &stype);
7862     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
7863 
7864     assert(val->sType == stype);
7865     vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext(dec, val->pNext);
7866     vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(dec, val);
7867 }
7868 
7869 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(const void * val)7870 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(const void *val)
7871 {
7872     /* no known/supported struct */
7873     return vn_sizeof_simple_pointer(NULL);
7874 }
7875 
7876 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7877 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7878 {
7879     size_t size = 0;
7880     /* skip val->{sType,pNext} */
7881     /* skip val->ycbcr2plane444Formats */
7882     return size;
7883 }
7884 
7885 static inline size_t
vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7886 vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7887 {
7888     size_t size = 0;
7889 
7890     size += vn_sizeof_VkStructureType(&val->sType);
7891     size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(val->pNext);
7892     size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(val);
7893 
7894     return size;
7895 }
7896 
7897 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)7898 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
7899 {
7900     /* no known/supported struct */
7901     vn_encode_simple_pointer(enc, NULL);
7902 }
7903 
7904 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7905 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7906 {
7907     /* skip val->{sType,pNext} */
7908     /* skip val->ycbcr2plane444Formats */
7909 }
7910 
7911 static inline void
vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT * val)7912 vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *val)
7913 {
7914     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
7915     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT });
7916     vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_pnext_partial(enc, val->pNext);
7917     vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(enc, val);
7918 }
7919 
7920 /* struct VkPhysicalDeviceProvokingVertexFeaturesEXT chain */
7921 
7922 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(const void * val)7923 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(const void *val)
7924 {
7925     /* no known/supported struct */
7926     return vn_sizeof_simple_pointer(NULL);
7927 }
7928 
7929 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)7930 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
7931 {
7932     size_t size = 0;
7933     /* skip val->{sType,pNext} */
7934     size += vn_sizeof_VkBool32(&val->provokingVertexLast);
7935     size += vn_sizeof_VkBool32(&val->transformFeedbackPreservesProvokingVertex);
7936     return size;
7937 }
7938 
7939 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)7940 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
7941 {
7942     size_t size = 0;
7943 
7944     size += vn_sizeof_VkStructureType(&val->sType);
7945     size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(val->pNext);
7946     size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(val);
7947 
7948     return size;
7949 }
7950 
7951 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)7952 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
7953 {
7954     /* no known/supported struct */
7955     vn_encode_simple_pointer(enc, NULL);
7956 }
7957 
7958 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)7959 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
7960 {
7961     /* skip val->{sType,pNext} */
7962     vn_encode_VkBool32(enc, &val->provokingVertexLast);
7963     vn_encode_VkBool32(enc, &val->transformFeedbackPreservesProvokingVertex);
7964 }
7965 
7966 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)7967 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
7968 {
7969     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
7970     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT });
7971     vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(enc, val->pNext);
7972     vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(enc, val);
7973 }
7974 
7975 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)7976 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
7977 {
7978     /* no known/supported struct */
7979     if (vn_decode_simple_pointer(dec))
7980         assert(false);
7981 }
7982 
7983 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexFeaturesEXT * val)7984 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
7985 {
7986     /* skip val->{sType,pNext} */
7987     vn_decode_VkBool32(dec, &val->provokingVertexLast);
7988     vn_decode_VkBool32(dec, &val->transformFeedbackPreservesProvokingVertex);
7989 }
7990 
7991 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexFeaturesEXT * val)7992 vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
7993 {
7994     VkStructureType stype;
7995     vn_decode_VkStructureType(dec, &stype);
7996     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
7997 
7998     assert(val->sType == stype);
7999     vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext(dec, val->pNext);
8000     vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(dec, val);
8001 }
8002 
8003 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(const void * val)8004 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(const void *val)
8005 {
8006     /* no known/supported struct */
8007     return vn_sizeof_simple_pointer(NULL);
8008 }
8009 
8010 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)8011 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
8012 {
8013     size_t size = 0;
8014     /* skip val->{sType,pNext} */
8015     /* skip val->provokingVertexLast */
8016     /* skip val->transformFeedbackPreservesProvokingVertex */
8017     return size;
8018 }
8019 
8020 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)8021 vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
8022 {
8023     size_t size = 0;
8024 
8025     size += vn_sizeof_VkStructureType(&val->sType);
8026     size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(val->pNext);
8027     size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(val);
8028 
8029     return size;
8030 }
8031 
8032 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)8033 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8034 {
8035     /* no known/supported struct */
8036     vn_encode_simple_pointer(enc, NULL);
8037 }
8038 
8039 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)8040 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
8041 {
8042     /* skip val->{sType,pNext} */
8043     /* skip val->provokingVertexLast */
8044     /* skip val->transformFeedbackPreservesProvokingVertex */
8045 }
8046 
8047 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexFeaturesEXT * val)8048 vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexFeaturesEXT *val)
8049 {
8050     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
8051     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT });
8052     vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_pnext_partial(enc, val->pNext);
8053     vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(enc, val);
8054 }
8055 
8056 /* struct VkPhysicalDeviceShaderIntegerDotProductFeatures chain */
8057 
8058 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(const void * val)8059 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(const void *val)
8060 {
8061     /* no known/supported struct */
8062     return vn_sizeof_simple_pointer(NULL);
8063 }
8064 
8065 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8066 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8067 {
8068     size_t size = 0;
8069     /* skip val->{sType,pNext} */
8070     size += vn_sizeof_VkBool32(&val->shaderIntegerDotProduct);
8071     return size;
8072 }
8073 
8074 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8075 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8076 {
8077     size_t size = 0;
8078 
8079     size += vn_sizeof_VkStructureType(&val->sType);
8080     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(val->pNext);
8081     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(val);
8082 
8083     return size;
8084 }
8085 
8086 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_encoder * enc,const void * val)8087 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
8088 {
8089     /* no known/supported struct */
8090     vn_encode_simple_pointer(enc, NULL);
8091 }
8092 
8093 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8094 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8095 {
8096     /* skip val->{sType,pNext} */
8097     vn_encode_VkBool32(enc, &val->shaderIntegerDotProduct);
8098 }
8099 
8100 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8101 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8102 {
8103     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
8104     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES });
8105     vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(enc, val->pNext);
8106     vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, val);
8107 }
8108 
8109 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_decoder * dec,const void * val)8110 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
8111 {
8112     /* no known/supported struct */
8113     if (vn_decode_simple_pointer(dec))
8114         assert(false);
8115 }
8116 
8117 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8118 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8119 {
8120     /* skip val->{sType,pNext} */
8121     vn_decode_VkBool32(dec, &val->shaderIntegerDotProduct);
8122 }
8123 
8124 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8125 vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8126 {
8127     VkStructureType stype;
8128     vn_decode_VkStructureType(dec, &stype);
8129     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
8130 
8131     assert(val->sType == stype);
8132     vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext(dec, val->pNext);
8133     vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(dec, val);
8134 }
8135 
8136 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(const void * val)8137 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(const void *val)
8138 {
8139     /* no known/supported struct */
8140     return vn_sizeof_simple_pointer(NULL);
8141 }
8142 
8143 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8144 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8145 {
8146     size_t size = 0;
8147     /* skip val->{sType,pNext} */
8148     /* skip val->shaderIntegerDotProduct */
8149     return size;
8150 }
8151 
8152 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8153 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8154 {
8155     size_t size = 0;
8156 
8157     size += vn_sizeof_VkStructureType(&val->sType);
8158     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(val->pNext);
8159     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(val);
8160 
8161     return size;
8162 }
8163 
8164 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)8165 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8166 {
8167     /* no known/supported struct */
8168     vn_encode_simple_pointer(enc, NULL);
8169 }
8170 
8171 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8172 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8173 {
8174     /* skip val->{sType,pNext} */
8175     /* skip val->shaderIntegerDotProduct */
8176 }
8177 
8178 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductFeatures * val)8179 vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductFeatures *val)
8180 {
8181     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
8182     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES });
8183     vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_pnext_partial(enc, val->pNext);
8184     vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(enc, val);
8185 }
8186 
8187 /* struct VkPhysicalDeviceDynamicRenderingFeatures chain */
8188 
8189 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(const void * val)8190 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(const void *val)
8191 {
8192     /* no known/supported struct */
8193     return vn_sizeof_simple_pointer(NULL);
8194 }
8195 
8196 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(const VkPhysicalDeviceDynamicRenderingFeatures * val)8197 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(const VkPhysicalDeviceDynamicRenderingFeatures *val)
8198 {
8199     size_t size = 0;
8200     /* skip val->{sType,pNext} */
8201     size += vn_sizeof_VkBool32(&val->dynamicRendering);
8202     return size;
8203 }
8204 
8205 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures * val)8206 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures *val)
8207 {
8208     size_t size = 0;
8209 
8210     size += vn_sizeof_VkStructureType(&val->sType);
8211     size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext(val->pNext);
8212     size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self(val);
8213 
8214     return size;
8215 }
8216 
8217 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_encoder * enc,const void * val)8218 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_encoder *enc, const void *val)
8219 {
8220     /* no known/supported struct */
8221     vn_encode_simple_pointer(enc, NULL);
8222 }
8223 
8224 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)8225 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
8226 {
8227     /* skip val->{sType,pNext} */
8228     vn_encode_VkBool32(enc, &val->dynamicRendering);
8229 }
8230 
8231 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)8232 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
8233 {
8234     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
8235     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES });
8236     vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(enc, val->pNext);
8237     vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, val);
8238 }
8239 
8240 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_decoder * dec,const void * val)8241 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(struct vn_cs_decoder *dec, const void *val)
8242 {
8243     /* no known/supported struct */
8244     if (vn_decode_simple_pointer(dec))
8245         assert(false);
8246 }
8247 
8248 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDynamicRenderingFeatures * val)8249 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingFeatures *val)
8250 {
8251     /* skip val->{sType,pNext} */
8252     vn_decode_VkBool32(dec, &val->dynamicRendering);
8253 }
8254 
8255 static inline void
vn_decode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_decoder * dec,VkPhysicalDeviceDynamicRenderingFeatures * val)8256 vn_decode_VkPhysicalDeviceDynamicRenderingFeatures(struct vn_cs_decoder *dec, VkPhysicalDeviceDynamicRenderingFeatures *val)
8257 {
8258     VkStructureType stype;
8259     vn_decode_VkStructureType(dec, &stype);
8260     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
8261 
8262     assert(val->sType == stype);
8263     vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_pnext(dec, val->pNext);
8264     vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(dec, val);
8265 }
8266 
8267 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(const void * val)8268 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(const void *val)
8269 {
8270     /* no known/supported struct */
8271     return vn_sizeof_simple_pointer(NULL);
8272 }
8273 
8274 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(const VkPhysicalDeviceDynamicRenderingFeatures * val)8275 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(const VkPhysicalDeviceDynamicRenderingFeatures *val)
8276 {
8277     size_t size = 0;
8278     /* skip val->{sType,pNext} */
8279     /* skip val->dynamicRendering */
8280     return size;
8281 }
8282 
8283 static inline size_t
vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_partial(const VkPhysicalDeviceDynamicRenderingFeatures * val)8284 vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_partial(const VkPhysicalDeviceDynamicRenderingFeatures *val)
8285 {
8286     size_t size = 0;
8287 
8288     size += vn_sizeof_VkStructureType(&val->sType);
8289     size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(val->pNext);
8290     size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(val);
8291 
8292     return size;
8293 }
8294 
8295 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(struct vn_cs_encoder * enc,const void * val)8296 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8297 {
8298     /* no known/supported struct */
8299     vn_encode_simple_pointer(enc, NULL);
8300 }
8301 
8302 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)8303 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
8304 {
8305     /* skip val->{sType,pNext} */
8306     /* skip val->dynamicRendering */
8307 }
8308 
8309 static inline void
vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDynamicRenderingFeatures * val)8310 vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDynamicRenderingFeatures *val)
8311 {
8312     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
8313     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES });
8314     vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_pnext_partial(enc, val->pNext);
8315     vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(enc, val);
8316 }
8317 
8318 /* struct VkPhysicalDeviceImageViewMinLodFeaturesEXT chain */
8319 
8320 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(const void * val)8321 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(const void *val)
8322 {
8323     /* no known/supported struct */
8324     return vn_sizeof_simple_pointer(NULL);
8325 }
8326 
8327 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8328 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8329 {
8330     size_t size = 0;
8331     /* skip val->{sType,pNext} */
8332     size += vn_sizeof_VkBool32(&val->minLod);
8333     return size;
8334 }
8335 
8336 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8337 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8338 {
8339     size_t size = 0;
8340 
8341     size += vn_sizeof_VkStructureType(&val->sType);
8342     size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(val->pNext);
8343     size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(val);
8344 
8345     return size;
8346 }
8347 
8348 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_encoder * enc,const void * val)8349 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
8350 {
8351     /* no known/supported struct */
8352     vn_encode_simple_pointer(enc, NULL);
8353 }
8354 
8355 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8356 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8357 {
8358     /* skip val->{sType,pNext} */
8359     vn_encode_VkBool32(enc, &val->minLod);
8360 }
8361 
8362 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8363 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8364 {
8365     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
8366     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT });
8367     vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(enc, val->pNext);
8368     vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(enc, val);
8369 }
8370 
8371 static inline void
vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_decoder * dec,const void * val)8372 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
8373 {
8374     /* no known/supported struct */
8375     if (vn_decode_simple_pointer(dec))
8376         assert(false);
8377 }
8378 
8379 static inline void
vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8380 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8381 {
8382     /* skip val->{sType,pNext} */
8383     vn_decode_VkBool32(dec, &val->minLod);
8384 }
8385 
8386 static inline void
vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8387 vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8388 {
8389     VkStructureType stype;
8390     vn_decode_VkStructureType(dec, &stype);
8391     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
8392 
8393     assert(val->sType == stype);
8394     vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext(dec, val->pNext);
8395     vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(dec, val);
8396 }
8397 
8398 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(const void * val)8399 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(const void *val)
8400 {
8401     /* no known/supported struct */
8402     return vn_sizeof_simple_pointer(NULL);
8403 }
8404 
8405 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8406 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8407 {
8408     size_t size = 0;
8409     /* skip val->{sType,pNext} */
8410     /* skip val->minLod */
8411     return size;
8412 }
8413 
8414 static inline size_t
vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8415 vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8416 {
8417     size_t size = 0;
8418 
8419     size += vn_sizeof_VkStructureType(&val->sType);
8420     size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(val->pNext);
8421     size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(val);
8422 
8423     return size;
8424 }
8425 
8426 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)8427 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
8428 {
8429     /* no known/supported struct */
8430     vn_encode_simple_pointer(enc, NULL);
8431 }
8432 
8433 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8434 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8435 {
8436     /* skip val->{sType,pNext} */
8437     /* skip val->minLod */
8438 }
8439 
8440 static inline void
vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageViewMinLodFeaturesEXT * val)8441 vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *val)
8442 {
8443     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
8444     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT });
8445     vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_pnext_partial(enc, val->pNext);
8446     vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(enc, val);
8447 }
8448 
8449 /* struct VkPhysicalDeviceFeatures2 chain */
8450 
8451 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void * val)8452 vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val)
8453 {
8454     const VkBaseInStructure *pnext = val;
8455     size_t size = 0;
8456 
8457     while (pnext) {
8458         switch ((int32_t)pnext->sType) {
8459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
8460             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
8461                 break;
8462             size += vn_sizeof_simple_pointer(pnext);
8463             size += vn_sizeof_VkStructureType(&pnext->sType);
8464             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8465             size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self((const VkPhysicalDevicePrivateDataFeatures *)pnext);
8466             return size;
8467         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
8468             size += vn_sizeof_simple_pointer(pnext);
8469             size += vn_sizeof_VkStructureType(&pnext->sType);
8470             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8471             size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
8472             return size;
8473         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
8474             size += vn_sizeof_simple_pointer(pnext);
8475             size += vn_sizeof_VkStructureType(&pnext->sType);
8476             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8477             size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
8478             return size;
8479         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
8480             size += vn_sizeof_simple_pointer(pnext);
8481             size += vn_sizeof_VkStructureType(&pnext->sType);
8482             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8483             size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
8484             return size;
8485         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
8486             size += vn_sizeof_simple_pointer(pnext);
8487             size += vn_sizeof_VkStructureType(&pnext->sType);
8488             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8489             size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
8490             return size;
8491         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
8492             size += vn_sizeof_simple_pointer(pnext);
8493             size += vn_sizeof_VkStructureType(&pnext->sType);
8494             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8495             size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
8496             return size;
8497         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
8498             size += vn_sizeof_simple_pointer(pnext);
8499             size += vn_sizeof_VkStructureType(&pnext->sType);
8500             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8501             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
8502             return size;
8503         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
8504             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
8505                 break;
8506             size += vn_sizeof_simple_pointer(pnext);
8507             size += vn_sizeof_VkStructureType(&pnext->sType);
8508             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8509             size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
8510             return size;
8511         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
8512             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
8513                 break;
8514             size += vn_sizeof_simple_pointer(pnext);
8515             size += vn_sizeof_VkStructureType(&pnext->sType);
8516             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8517             size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext);
8518             return size;
8519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
8520             size += vn_sizeof_simple_pointer(pnext);
8521             size += vn_sizeof_VkStructureType(&pnext->sType);
8522             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8523             size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
8524             return size;
8525         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
8526             size += vn_sizeof_simple_pointer(pnext);
8527             size += vn_sizeof_VkStructureType(&pnext->sType);
8528             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8529             size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
8530             return size;
8531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
8532             size += vn_sizeof_simple_pointer(pnext);
8533             size += vn_sizeof_VkStructureType(&pnext->sType);
8534             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8535             size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
8536             return size;
8537         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
8538             size += vn_sizeof_simple_pointer(pnext);
8539             size += vn_sizeof_VkStructureType(&pnext->sType);
8540             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8541             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
8542             return size;
8543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
8544             size += vn_sizeof_simple_pointer(pnext);
8545             size += vn_sizeof_VkStructureType(&pnext->sType);
8546             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8547             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
8548             return size;
8549         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
8550             size += vn_sizeof_simple_pointer(pnext);
8551             size += vn_sizeof_VkStructureType(&pnext->sType);
8552             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8553             size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
8554             return size;
8555         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
8556             if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
8557                 break;
8558             size += vn_sizeof_simple_pointer(pnext);
8559             size += vn_sizeof_VkStructureType(&pnext->sType);
8560             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8561             size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self((const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
8562             return size;
8563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
8564             size += vn_sizeof_simple_pointer(pnext);
8565             size += vn_sizeof_VkStructureType(&pnext->sType);
8566             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8567             size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
8568             return size;
8569         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
8570             size += vn_sizeof_simple_pointer(pnext);
8571             size += vn_sizeof_VkStructureType(&pnext->sType);
8572             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8573             size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
8574             return size;
8575         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
8576             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
8577                 break;
8578             size += vn_sizeof_simple_pointer(pnext);
8579             size += vn_sizeof_VkStructureType(&pnext->sType);
8580             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8581             size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self((const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
8582             return size;
8583         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
8584             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
8585                 break;
8586             size += vn_sizeof_simple_pointer(pnext);
8587             size += vn_sizeof_VkStructureType(&pnext->sType);
8588             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8589             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
8590             return size;
8591         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
8592             size += vn_sizeof_simple_pointer(pnext);
8593             size += vn_sizeof_VkStructureType(&pnext->sType);
8594             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8595             size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
8596             return size;
8597         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
8598             size += vn_sizeof_simple_pointer(pnext);
8599             size += vn_sizeof_VkStructureType(&pnext->sType);
8600             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8601             size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
8602             return size;
8603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
8604             if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
8605                 break;
8606             size += vn_sizeof_simple_pointer(pnext);
8607             size += vn_sizeof_VkStructureType(&pnext->sType);
8608             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8609             size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self((const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
8610             return size;
8611         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
8612             size += vn_sizeof_simple_pointer(pnext);
8613             size += vn_sizeof_VkStructureType(&pnext->sType);
8614             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8615             size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
8616             return size;
8617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
8618             size += vn_sizeof_simple_pointer(pnext);
8619             size += vn_sizeof_VkStructureType(&pnext->sType);
8620             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8621             size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
8622             return size;
8623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
8624             if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
8625                 break;
8626             size += vn_sizeof_simple_pointer(pnext);
8627             size += vn_sizeof_VkStructureType(&pnext->sType);
8628             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8629             size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
8630             return size;
8631         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
8632             if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
8633                 break;
8634             size += vn_sizeof_simple_pointer(pnext);
8635             size += vn_sizeof_VkStructureType(&pnext->sType);
8636             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8637             size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self((const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
8638             return size;
8639         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
8640             size += vn_sizeof_simple_pointer(pnext);
8641             size += vn_sizeof_VkStructureType(&pnext->sType);
8642             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8643             size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
8644             return size;
8645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
8646             if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
8647                 break;
8648             size += vn_sizeof_simple_pointer(pnext);
8649             size += vn_sizeof_VkStructureType(&pnext->sType);
8650             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8651             size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
8652             return size;
8653         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
8654             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
8655                 break;
8656             size += vn_sizeof_simple_pointer(pnext);
8657             size += vn_sizeof_VkStructureType(&pnext->sType);
8658             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8659             size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
8660             return size;
8661         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
8662             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
8663                 break;
8664             size += vn_sizeof_simple_pointer(pnext);
8665             size += vn_sizeof_VkStructureType(&pnext->sType);
8666             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8667             size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
8668             return size;
8669         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
8670             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
8671                 break;
8672             size += vn_sizeof_simple_pointer(pnext);
8673             size += vn_sizeof_VkStructureType(&pnext->sType);
8674             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8675             size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self((const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
8676             return size;
8677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
8678             if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
8679                 break;
8680             size += vn_sizeof_simple_pointer(pnext);
8681             size += vn_sizeof_VkStructureType(&pnext->sType);
8682             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8683             size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
8684             return size;
8685         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
8686             size += vn_sizeof_simple_pointer(pnext);
8687             size += vn_sizeof_VkStructureType(&pnext->sType);
8688             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8689             size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
8690             return size;
8691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
8692             size += vn_sizeof_simple_pointer(pnext);
8693             size += vn_sizeof_VkStructureType(&pnext->sType);
8694             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8695             size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
8696             return size;
8697         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
8698             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
8699                 break;
8700             size += vn_sizeof_simple_pointer(pnext);
8701             size += vn_sizeof_VkStructureType(&pnext->sType);
8702             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8703             size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self((const VkPhysicalDeviceVulkan13Features *)pnext);
8704             return size;
8705         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
8706             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
8707                 break;
8708             size += vn_sizeof_simple_pointer(pnext);
8709             size += vn_sizeof_VkStructureType(&pnext->sType);
8710             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8711             size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self((const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
8712             return size;
8713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
8714             if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
8715                 break;
8716             size += vn_sizeof_simple_pointer(pnext);
8717             size += vn_sizeof_VkStructureType(&pnext->sType);
8718             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8719             size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
8720             return size;
8721         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
8722             if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
8723                 break;
8724             size += vn_sizeof_simple_pointer(pnext);
8725             size += vn_sizeof_VkStructureType(&pnext->sType);
8726             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8727             size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
8728             return size;
8729         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
8730             if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
8731                 break;
8732             size += vn_sizeof_simple_pointer(pnext);
8733             size += vn_sizeof_VkStructureType(&pnext->sType);
8734             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8735             size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
8736             return size;
8737         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
8738             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
8739                 break;
8740             size += vn_sizeof_simple_pointer(pnext);
8741             size += vn_sizeof_VkStructureType(&pnext->sType);
8742             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8743             size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self((const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
8744             return size;
8745         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
8746             if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
8747                 break;
8748             size += vn_sizeof_simple_pointer(pnext);
8749             size += vn_sizeof_VkStructureType(&pnext->sType);
8750             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8751             size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self((const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
8752             return size;
8753         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
8754             if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
8755                 break;
8756             size += vn_sizeof_simple_pointer(pnext);
8757             size += vn_sizeof_VkStructureType(&pnext->sType);
8758             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8759             size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
8760             return size;
8761         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
8762             if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
8763                 break;
8764             size += vn_sizeof_simple_pointer(pnext);
8765             size += vn_sizeof_VkStructureType(&pnext->sType);
8766             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8767             size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
8768             return size;
8769         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
8770             if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
8771                 break;
8772             size += vn_sizeof_simple_pointer(pnext);
8773             size += vn_sizeof_VkStructureType(&pnext->sType);
8774             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8775             size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self((const VkPhysicalDeviceSynchronization2Features *)pnext);
8776             return size;
8777         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
8778             if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
8779                 break;
8780             size += vn_sizeof_simple_pointer(pnext);
8781             size += vn_sizeof_VkStructureType(&pnext->sType);
8782             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8783             size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
8784             return size;
8785         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
8786             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
8787                 break;
8788             size += vn_sizeof_simple_pointer(pnext);
8789             size += vn_sizeof_VkStructureType(&pnext->sType);
8790             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8791             size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self((const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
8792             return size;
8793         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
8794             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
8795                 break;
8796             size += vn_sizeof_simple_pointer(pnext);
8797             size += vn_sizeof_VkStructureType(&pnext->sType);
8798             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8799             size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
8800             return size;
8801         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
8802             if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
8803                 break;
8804             size += vn_sizeof_simple_pointer(pnext);
8805             size += vn_sizeof_VkStructureType(&pnext->sType);
8806             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8807             size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
8808             return size;
8809         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
8810             if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
8811                 break;
8812             size += vn_sizeof_simple_pointer(pnext);
8813             size += vn_sizeof_VkStructureType(&pnext->sType);
8814             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
8815             size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self((const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
8816             return size;
8817         default:
8818             /* ignore unknown/unsupported struct */
8819             break;
8820         }
8821         pnext = pnext->pNext;
8822     }
8823 
8824     return vn_sizeof_simple_pointer(NULL);
8825 }
8826 
8827 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 * val)8828 vn_sizeof_VkPhysicalDeviceFeatures2_self(const VkPhysicalDeviceFeatures2 *val)
8829 {
8830     size_t size = 0;
8831     /* skip val->{sType,pNext} */
8832     size += vn_sizeof_VkPhysicalDeviceFeatures(&val->features);
8833     return size;
8834 }
8835 
8836 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 * val)8837 vn_sizeof_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2 *val)
8838 {
8839     size_t size = 0;
8840 
8841     size += vn_sizeof_VkStructureType(&val->sType);
8842     size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(val->pNext);
8843     size += vn_sizeof_VkPhysicalDeviceFeatures2_self(val);
8844 
8845     return size;
8846 }
8847 
8848 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder * enc,const void * val)8849 vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void *val)
8850 {
8851     const VkBaseInStructure *pnext = val;
8852 
8853     while (pnext) {
8854         switch ((int32_t)pnext->sType) {
8855         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
8856             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
8857                 break;
8858             vn_encode_simple_pointer(enc, pnext);
8859             vn_encode_VkStructureType(enc, &pnext->sType);
8860             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8861             vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext);
8862             return;
8863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
8864             vn_encode_simple_pointer(enc, pnext);
8865             vn_encode_VkStructureType(enc, &pnext->sType);
8866             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8867             vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
8868             return;
8869         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
8870             vn_encode_simple_pointer(enc, pnext);
8871             vn_encode_VkStructureType(enc, &pnext->sType);
8872             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8873             vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
8874             return;
8875         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
8876             vn_encode_simple_pointer(enc, pnext);
8877             vn_encode_VkStructureType(enc, &pnext->sType);
8878             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8879             vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
8880             return;
8881         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
8882             vn_encode_simple_pointer(enc, pnext);
8883             vn_encode_VkStructureType(enc, &pnext->sType);
8884             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8885             vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
8886             return;
8887         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
8888             vn_encode_simple_pointer(enc, pnext);
8889             vn_encode_VkStructureType(enc, &pnext->sType);
8890             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8891             vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
8892             return;
8893         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
8894             vn_encode_simple_pointer(enc, pnext);
8895             vn_encode_VkStructureType(enc, &pnext->sType);
8896             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8897             vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
8898             return;
8899         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
8900             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
8901                 break;
8902             vn_encode_simple_pointer(enc, pnext);
8903             vn_encode_VkStructureType(enc, &pnext->sType);
8904             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8905             vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
8906             return;
8907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
8908             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
8909                 break;
8910             vn_encode_simple_pointer(enc, pnext);
8911             vn_encode_VkStructureType(enc, &pnext->sType);
8912             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8913             vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
8914             return;
8915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
8916             vn_encode_simple_pointer(enc, pnext);
8917             vn_encode_VkStructureType(enc, &pnext->sType);
8918             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8919             vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
8920             return;
8921         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
8922             vn_encode_simple_pointer(enc, pnext);
8923             vn_encode_VkStructureType(enc, &pnext->sType);
8924             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8925             vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
8926             return;
8927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
8928             vn_encode_simple_pointer(enc, pnext);
8929             vn_encode_VkStructureType(enc, &pnext->sType);
8930             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8931             vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
8932             return;
8933         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
8934             vn_encode_simple_pointer(enc, pnext);
8935             vn_encode_VkStructureType(enc, &pnext->sType);
8936             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8937             vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
8938             return;
8939         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
8940             vn_encode_simple_pointer(enc, pnext);
8941             vn_encode_VkStructureType(enc, &pnext->sType);
8942             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8943             vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
8944             return;
8945         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
8946             vn_encode_simple_pointer(enc, pnext);
8947             vn_encode_VkStructureType(enc, &pnext->sType);
8948             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8949             vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
8950             return;
8951         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
8952             if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
8953                 break;
8954             vn_encode_simple_pointer(enc, pnext);
8955             vn_encode_VkStructureType(enc, &pnext->sType);
8956             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8957             vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(enc, (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
8958             return;
8959         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
8960             vn_encode_simple_pointer(enc, pnext);
8961             vn_encode_VkStructureType(enc, &pnext->sType);
8962             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8963             vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
8964             return;
8965         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
8966             vn_encode_simple_pointer(enc, pnext);
8967             vn_encode_VkStructureType(enc, &pnext->sType);
8968             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8969             vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
8970             return;
8971         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
8972             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
8973                 break;
8974             vn_encode_simple_pointer(enc, pnext);
8975             vn_encode_VkStructureType(enc, &pnext->sType);
8976             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8977             vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(enc, (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
8978             return;
8979         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
8980             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
8981                 break;
8982             vn_encode_simple_pointer(enc, pnext);
8983             vn_encode_VkStructureType(enc, &pnext->sType);
8984             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8985             vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
8986             return;
8987         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
8988             vn_encode_simple_pointer(enc, pnext);
8989             vn_encode_VkStructureType(enc, &pnext->sType);
8990             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8991             vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
8992             return;
8993         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
8994             vn_encode_simple_pointer(enc, pnext);
8995             vn_encode_VkStructureType(enc, &pnext->sType);
8996             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
8997             vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
8998             return;
8999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
9000             if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
9001                 break;
9002             vn_encode_simple_pointer(enc, pnext);
9003             vn_encode_VkStructureType(enc, &pnext->sType);
9004             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9005             vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(enc, (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
9006             return;
9007         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
9008             vn_encode_simple_pointer(enc, pnext);
9009             vn_encode_VkStructureType(enc, &pnext->sType);
9010             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9011             vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
9012             return;
9013         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
9014             vn_encode_simple_pointer(enc, pnext);
9015             vn_encode_VkStructureType(enc, &pnext->sType);
9016             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9017             vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
9018             return;
9019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
9020             if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
9021                 break;
9022             vn_encode_simple_pointer(enc, pnext);
9023             vn_encode_VkStructureType(enc, &pnext->sType);
9024             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9025             vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
9026             return;
9027         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
9028             if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
9029                 break;
9030             vn_encode_simple_pointer(enc, pnext);
9031             vn_encode_VkStructureType(enc, &pnext->sType);
9032             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9033             vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(enc, (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
9034             return;
9035         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
9036             vn_encode_simple_pointer(enc, pnext);
9037             vn_encode_VkStructureType(enc, &pnext->sType);
9038             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9039             vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
9040             return;
9041         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
9042             if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
9043                 break;
9044             vn_encode_simple_pointer(enc, pnext);
9045             vn_encode_VkStructureType(enc, &pnext->sType);
9046             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9047             vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
9048             return;
9049         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
9050             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
9051                 break;
9052             vn_encode_simple_pointer(enc, pnext);
9053             vn_encode_VkStructureType(enc, &pnext->sType);
9054             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9055             vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
9056             return;
9057         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
9058             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
9059                 break;
9060             vn_encode_simple_pointer(enc, pnext);
9061             vn_encode_VkStructureType(enc, &pnext->sType);
9062             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9063             vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
9064             return;
9065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
9066             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
9067                 break;
9068             vn_encode_simple_pointer(enc, pnext);
9069             vn_encode_VkStructureType(enc, &pnext->sType);
9070             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9071             vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(enc, (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
9072             return;
9073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
9074             if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
9075                 break;
9076             vn_encode_simple_pointer(enc, pnext);
9077             vn_encode_VkStructureType(enc, &pnext->sType);
9078             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9079             vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
9080             return;
9081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
9082             vn_encode_simple_pointer(enc, pnext);
9083             vn_encode_VkStructureType(enc, &pnext->sType);
9084             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9085             vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
9086             return;
9087         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
9088             vn_encode_simple_pointer(enc, pnext);
9089             vn_encode_VkStructureType(enc, &pnext->sType);
9090             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9091             vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
9092             return;
9093         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
9094             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
9095                 break;
9096             vn_encode_simple_pointer(enc, pnext);
9097             vn_encode_VkStructureType(enc, &pnext->sType);
9098             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9099             vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, (const VkPhysicalDeviceVulkan13Features *)pnext);
9100             return;
9101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
9102             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
9103                 break;
9104             vn_encode_simple_pointer(enc, pnext);
9105             vn_encode_VkStructureType(enc, &pnext->sType);
9106             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9107             vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(enc, (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
9108             return;
9109         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
9110             if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
9111                 break;
9112             vn_encode_simple_pointer(enc, pnext);
9113             vn_encode_VkStructureType(enc, &pnext->sType);
9114             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9115             vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
9116             return;
9117         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
9118             if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
9119                 break;
9120             vn_encode_simple_pointer(enc, pnext);
9121             vn_encode_VkStructureType(enc, &pnext->sType);
9122             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9123             vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
9124             return;
9125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
9126             if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
9127                 break;
9128             vn_encode_simple_pointer(enc, pnext);
9129             vn_encode_VkStructureType(enc, &pnext->sType);
9130             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9131             vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
9132             return;
9133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
9134             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
9135                 break;
9136             vn_encode_simple_pointer(enc, pnext);
9137             vn_encode_VkStructureType(enc, &pnext->sType);
9138             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9139             vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(enc, (const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
9140             return;
9141         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
9142             if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
9143                 break;
9144             vn_encode_simple_pointer(enc, pnext);
9145             vn_encode_VkStructureType(enc, &pnext->sType);
9146             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9147             vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
9148             return;
9149         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
9150             if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
9151                 break;
9152             vn_encode_simple_pointer(enc, pnext);
9153             vn_encode_VkStructureType(enc, &pnext->sType);
9154             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9155             vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
9156             return;
9157         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
9158             if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
9159                 break;
9160             vn_encode_simple_pointer(enc, pnext);
9161             vn_encode_VkStructureType(enc, &pnext->sType);
9162             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9163             vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
9164             return;
9165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
9166             if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
9167                 break;
9168             vn_encode_simple_pointer(enc, pnext);
9169             vn_encode_VkStructureType(enc, &pnext->sType);
9170             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9171             vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext);
9172             return;
9173         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
9174             if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
9175                 break;
9176             vn_encode_simple_pointer(enc, pnext);
9177             vn_encode_VkStructureType(enc, &pnext->sType);
9178             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9179             vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
9180             return;
9181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
9182             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
9183                 break;
9184             vn_encode_simple_pointer(enc, pnext);
9185             vn_encode_VkStructureType(enc, &pnext->sType);
9186             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9187             vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(enc, (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
9188             return;
9189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
9190             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
9191                 break;
9192             vn_encode_simple_pointer(enc, pnext);
9193             vn_encode_VkStructureType(enc, &pnext->sType);
9194             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9195             vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
9196             return;
9197         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
9198             if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
9199                 break;
9200             vn_encode_simple_pointer(enc, pnext);
9201             vn_encode_VkStructureType(enc, &pnext->sType);
9202             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9203             vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
9204             return;
9205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
9206             if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
9207                 break;
9208             vn_encode_simple_pointer(enc, pnext);
9209             vn_encode_VkStructureType(enc, &pnext->sType);
9210             vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
9211             vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(enc, (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
9212             return;
9213         default:
9214             /* ignore unknown/unsupported struct */
9215             break;
9216         }
9217         pnext = pnext->pNext;
9218     }
9219 
9220     vn_encode_simple_pointer(enc, NULL);
9221 }
9222 
9223 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)9224 vn_encode_VkPhysicalDeviceFeatures2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
9225 {
9226     /* skip val->{sType,pNext} */
9227     vn_encode_VkPhysicalDeviceFeatures(enc, &val->features);
9228 }
9229 
9230 static inline void
vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)9231 vn_encode_VkPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
9232 {
9233     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
9234     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
9235     vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, val->pNext);
9236     vn_encode_VkPhysicalDeviceFeatures2_self(enc, val);
9237 }
9238 
9239 static inline void
vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder * dec,const void * val)9240 vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void *val)
9241 {
9242     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
9243     VkStructureType stype;
9244 
9245     if (!vn_decode_simple_pointer(dec))
9246         return;
9247 
9248     vn_decode_VkStructureType(dec, &stype);
9249     while (true) {
9250         assert(pnext);
9251         if (pnext->sType == stype)
9252             break;
9253 
9254         pnext = pnext->pNext;
9255     }
9256 
9257     switch ((int32_t)pnext->sType) {
9258     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
9259         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9260         vn_decode_VkPhysicalDevicePrivateDataFeatures_self(dec, (VkPhysicalDevicePrivateDataFeatures *)pnext);
9261         break;
9262     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
9263         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9264         vn_decode_VkPhysicalDeviceVariablePointersFeatures_self(dec, (VkPhysicalDeviceVariablePointersFeatures *)pnext);
9265         break;
9266     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
9267         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9268         vn_decode_VkPhysicalDeviceMultiviewFeatures_self(dec, (VkPhysicalDeviceMultiviewFeatures *)pnext);
9269         break;
9270     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
9271         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9272         vn_decode_VkPhysicalDevice16BitStorageFeatures_self(dec, (VkPhysicalDevice16BitStorageFeatures *)pnext);
9273         break;
9274     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
9275         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9276         vn_decode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(dec, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
9277         break;
9278     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
9279         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9280         vn_decode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(dec, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
9281         break;
9282     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
9283         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9284         vn_decode_VkPhysicalDeviceProtectedMemoryFeatures_self(dec, (VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
9285         break;
9286     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
9287         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9288         vn_decode_VkPhysicalDeviceInlineUniformBlockFeatures_self(dec, (VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
9289         break;
9290     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
9291         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9292         vn_decode_VkPhysicalDeviceMaintenance4Features_self(dec, (VkPhysicalDeviceMaintenance4Features *)pnext);
9293         break;
9294     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
9295         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9296         vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
9297         break;
9298     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
9299         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9300         vn_decode_VkPhysicalDeviceShaderFloat16Int8Features_self(dec, (VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
9301         break;
9302     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
9303         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9304         vn_decode_VkPhysicalDeviceHostQueryResetFeatures_self(dec, (VkPhysicalDeviceHostQueryResetFeatures *)pnext);
9305         break;
9306     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
9307         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9308         vn_decode_VkPhysicalDeviceDescriptorIndexingFeatures_self(dec, (VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
9309         break;
9310     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
9311         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9312         vn_decode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(dec, (VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
9313         break;
9314     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
9315         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9316         vn_decode_VkPhysicalDevice8BitStorageFeatures_self(dec, (VkPhysicalDevice8BitStorageFeatures *)pnext);
9317         break;
9318     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
9319         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9320         vn_decode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(dec, (VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
9321         break;
9322     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
9323         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9324         vn_decode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(dec, (VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
9325         break;
9326     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
9327         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9328         vn_decode_VkPhysicalDeviceShaderAtomicInt64Features_self(dec, (VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
9329         break;
9330     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
9331         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9332         vn_decode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(dec, (VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
9333         break;
9334     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
9335         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9336         vn_decode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
9337         break;
9338     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
9339         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9340         vn_decode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(dec, (VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
9341         break;
9342     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
9343         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9344         vn_decode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(dec, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
9345         break;
9346     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
9347         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9348         vn_decode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(dec, (VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
9349         break;
9350     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
9351         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9352         vn_decode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(dec, (VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
9353         break;
9354     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
9355         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9356         vn_decode_VkPhysicalDeviceImagelessFramebufferFeatures_self(dec, (VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
9357         break;
9358     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
9359         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9360         vn_decode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(dec, (VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
9361         break;
9362     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
9363         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9364         vn_decode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(dec, (VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
9365         break;
9366     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
9367         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9368         vn_decode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(dec, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
9369         break;
9370     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
9371         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9372         vn_decode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(dec, (VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
9373         break;
9374     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
9375         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9376         vn_decode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(dec, (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
9377         break;
9378     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
9379         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9380         vn_decode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(dec, (VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
9381         break;
9382     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
9383         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9384         vn_decode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(dec, (VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
9385         break;
9386     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
9387         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9388         vn_decode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(dec, (VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
9389         break;
9390     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
9391         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9392         vn_decode_VkPhysicalDeviceVulkan11Features_self(dec, (VkPhysicalDeviceVulkan11Features *)pnext);
9393         break;
9394     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
9395         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9396         vn_decode_VkPhysicalDeviceVulkan12Features_self(dec, (VkPhysicalDeviceVulkan12Features *)pnext);
9397         break;
9398     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
9399         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9400         vn_decode_VkPhysicalDeviceVulkan13Features_self(dec, (VkPhysicalDeviceVulkan13Features *)pnext);
9401         break;
9402     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
9403         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9404         vn_decode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(dec, (VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
9405         break;
9406     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
9407         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9408         vn_decode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
9409         break;
9410     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
9411         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9412         vn_decode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(dec, (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
9413         break;
9414     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
9415         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9416         vn_decode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(dec, (VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
9417         break;
9418     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
9419         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9420         vn_decode_VkPhysicalDeviceRobustness2FeaturesEXT_self(dec, (VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
9421         break;
9422     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
9423         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9424         vn_decode_VkPhysicalDeviceImageRobustnessFeatures_self(dec, (VkPhysicalDeviceImageRobustnessFeatures *)pnext);
9425         break;
9426     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
9427         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9428         vn_decode_VkPhysicalDevice4444FormatsFeaturesEXT_self(dec, (VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
9429         break;
9430     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
9431         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9432         vn_decode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(dec, (VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
9433         break;
9434     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
9435         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9436         vn_decode_VkPhysicalDeviceSynchronization2Features_self(dec, (VkPhysicalDeviceSynchronization2Features *)pnext);
9437         break;
9438     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
9439         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9440         vn_decode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(dec, (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
9441         break;
9442     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
9443         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9444         vn_decode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(dec, (VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
9445         break;
9446     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
9447         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9448         vn_decode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(dec, (VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
9449         break;
9450     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
9451         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9452         vn_decode_VkPhysicalDeviceDynamicRenderingFeatures_self(dec, (VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
9453         break;
9454     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
9455         vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
9456         vn_decode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(dec, (VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
9457         break;
9458     default:
9459         assert(false);
9460         break;
9461     }
9462 }
9463 
9464 static inline void
vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)9465 vn_decode_VkPhysicalDeviceFeatures2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
9466 {
9467     /* skip val->{sType,pNext} */
9468     vn_decode_VkPhysicalDeviceFeatures(dec, &val->features);
9469 }
9470 
9471 static inline void
vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder * dec,VkPhysicalDeviceFeatures2 * val)9472 vn_decode_VkPhysicalDeviceFeatures2(struct vn_cs_decoder *dec, VkPhysicalDeviceFeatures2 *val)
9473 {
9474     VkStructureType stype;
9475     vn_decode_VkStructureType(dec, &stype);
9476     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
9477 
9478     assert(val->sType == stype);
9479     vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, val->pNext);
9480     vn_decode_VkPhysicalDeviceFeatures2_self(dec, val);
9481 }
9482 
9483 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void * val)9484 vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val)
9485 {
9486     const VkBaseInStructure *pnext = val;
9487     size_t size = 0;
9488 
9489     while (pnext) {
9490         switch ((int32_t)pnext->sType) {
9491         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
9492             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
9493                 break;
9494             size += vn_sizeof_simple_pointer(pnext);
9495             size += vn_sizeof_VkStructureType(&pnext->sType);
9496             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9497             size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self_partial((const VkPhysicalDevicePrivateDataFeatures *)pnext);
9498             return size;
9499         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
9500             size += vn_sizeof_simple_pointer(pnext);
9501             size += vn_sizeof_VkStructureType(&pnext->sType);
9502             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9503             size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self_partial((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
9504             return size;
9505         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
9506             size += vn_sizeof_simple_pointer(pnext);
9507             size += vn_sizeof_VkStructureType(&pnext->sType);
9508             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9509             size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self_partial((const VkPhysicalDeviceMultiviewFeatures *)pnext);
9510             return size;
9511         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
9512             size += vn_sizeof_simple_pointer(pnext);
9513             size += vn_sizeof_VkStructureType(&pnext->sType);
9514             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9515             size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self_partial((const VkPhysicalDevice16BitStorageFeatures *)pnext);
9516             return size;
9517         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
9518             size += vn_sizeof_simple_pointer(pnext);
9519             size += vn_sizeof_VkStructureType(&pnext->sType);
9520             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9521             size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
9522             return size;
9523         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
9524             size += vn_sizeof_simple_pointer(pnext);
9525             size += vn_sizeof_VkStructureType(&pnext->sType);
9526             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9527             size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
9528             return size;
9529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
9530             size += vn_sizeof_simple_pointer(pnext);
9531             size += vn_sizeof_VkStructureType(&pnext->sType);
9532             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9533             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self_partial((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
9534             return size;
9535         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
9536             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
9537                 break;
9538             size += vn_sizeof_simple_pointer(pnext);
9539             size += vn_sizeof_VkStructureType(&pnext->sType);
9540             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9541             size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
9542             return size;
9543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
9544             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
9545                 break;
9546             size += vn_sizeof_simple_pointer(pnext);
9547             size += vn_sizeof_VkStructureType(&pnext->sType);
9548             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9549             size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial((const VkPhysicalDeviceMaintenance4Features *)pnext);
9550             return size;
9551         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
9552             size += vn_sizeof_simple_pointer(pnext);
9553             size += vn_sizeof_VkStructureType(&pnext->sType);
9554             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9555             size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
9556             return size;
9557         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
9558             size += vn_sizeof_simple_pointer(pnext);
9559             size += vn_sizeof_VkStructureType(&pnext->sType);
9560             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9561             size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self_partial((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
9562             return size;
9563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
9564             size += vn_sizeof_simple_pointer(pnext);
9565             size += vn_sizeof_VkStructureType(&pnext->sType);
9566             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9567             size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self_partial((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
9568             return size;
9569         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
9570             size += vn_sizeof_simple_pointer(pnext);
9571             size += vn_sizeof_VkStructureType(&pnext->sType);
9572             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9573             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
9574             return size;
9575         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
9576             size += vn_sizeof_simple_pointer(pnext);
9577             size += vn_sizeof_VkStructureType(&pnext->sType);
9578             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9579             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
9580             return size;
9581         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
9582             size += vn_sizeof_simple_pointer(pnext);
9583             size += vn_sizeof_VkStructureType(&pnext->sType);
9584             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9585             size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self_partial((const VkPhysicalDevice8BitStorageFeatures *)pnext);
9586             return size;
9587         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
9588             if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
9589                 break;
9590             size += vn_sizeof_simple_pointer(pnext);
9591             size += vn_sizeof_VkStructureType(&pnext->sType);
9592             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9593             size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial((const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
9594             return size;
9595         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
9596             size += vn_sizeof_simple_pointer(pnext);
9597             size += vn_sizeof_VkStructureType(&pnext->sType);
9598             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9599             size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
9600             return size;
9601         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
9602             size += vn_sizeof_simple_pointer(pnext);
9603             size += vn_sizeof_VkStructureType(&pnext->sType);
9604             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9605             size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self_partial((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
9606             return size;
9607         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
9608             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
9609                 break;
9610             size += vn_sizeof_simple_pointer(pnext);
9611             size += vn_sizeof_VkStructureType(&pnext->sType);
9612             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9613             size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial((const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
9614             return size;
9615         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
9616             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
9617                 break;
9618             size += vn_sizeof_simple_pointer(pnext);
9619             size += vn_sizeof_VkStructureType(&pnext->sType);
9620             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9621             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
9622             return size;
9623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
9624             size += vn_sizeof_simple_pointer(pnext);
9625             size += vn_sizeof_VkStructureType(&pnext->sType);
9626             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9627             size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
9628             return size;
9629         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
9630             size += vn_sizeof_simple_pointer(pnext);
9631             size += vn_sizeof_VkStructureType(&pnext->sType);
9632             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9633             size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
9634             return size;
9635         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
9636             if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
9637                 break;
9638             size += vn_sizeof_simple_pointer(pnext);
9639             size += vn_sizeof_VkStructureType(&pnext->sType);
9640             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9641             size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial((const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
9642             return size;
9643         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
9644             size += vn_sizeof_simple_pointer(pnext);
9645             size += vn_sizeof_VkStructureType(&pnext->sType);
9646             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9647             size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
9648             return size;
9649         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
9650             size += vn_sizeof_simple_pointer(pnext);
9651             size += vn_sizeof_VkStructureType(&pnext->sType);
9652             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9653             size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
9654             return size;
9655         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
9656             if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
9657                 break;
9658             size += vn_sizeof_simple_pointer(pnext);
9659             size += vn_sizeof_VkStructureType(&pnext->sType);
9660             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9661             size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
9662             return size;
9663         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
9664             if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
9665                 break;
9666             size += vn_sizeof_simple_pointer(pnext);
9667             size += vn_sizeof_VkStructureType(&pnext->sType);
9668             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9669             size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial((const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
9670             return size;
9671         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
9672             size += vn_sizeof_simple_pointer(pnext);
9673             size += vn_sizeof_VkStructureType(&pnext->sType);
9674             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9675             size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
9676             return size;
9677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
9678             if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
9679                 break;
9680             size += vn_sizeof_simple_pointer(pnext);
9681             size += vn_sizeof_VkStructureType(&pnext->sType);
9682             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9683             size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
9684             return size;
9685         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
9686             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
9687                 break;
9688             size += vn_sizeof_simple_pointer(pnext);
9689             size += vn_sizeof_VkStructureType(&pnext->sType);
9690             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9691             size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
9692             return size;
9693         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
9694             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
9695                 break;
9696             size += vn_sizeof_simple_pointer(pnext);
9697             size += vn_sizeof_VkStructureType(&pnext->sType);
9698             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9699             size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
9700             return size;
9701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
9702             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
9703                 break;
9704             size += vn_sizeof_simple_pointer(pnext);
9705             size += vn_sizeof_VkStructureType(&pnext->sType);
9706             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9707             size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial((const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
9708             return size;
9709         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
9710             if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
9711                 break;
9712             size += vn_sizeof_simple_pointer(pnext);
9713             size += vn_sizeof_VkStructureType(&pnext->sType);
9714             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9715             size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
9716             return size;
9717         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
9718             size += vn_sizeof_simple_pointer(pnext);
9719             size += vn_sizeof_VkStructureType(&pnext->sType);
9720             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9721             size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self_partial((const VkPhysicalDeviceVulkan11Features *)pnext);
9722             return size;
9723         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
9724             size += vn_sizeof_simple_pointer(pnext);
9725             size += vn_sizeof_VkStructureType(&pnext->sType);
9726             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9727             size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self_partial((const VkPhysicalDeviceVulkan12Features *)pnext);
9728             return size;
9729         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
9730             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
9731                 break;
9732             size += vn_sizeof_simple_pointer(pnext);
9733             size += vn_sizeof_VkStructureType(&pnext->sType);
9734             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9735             size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self_partial((const VkPhysicalDeviceVulkan13Features *)pnext);
9736             return size;
9737         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
9738             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
9739                 break;
9740             size += vn_sizeof_simple_pointer(pnext);
9741             size += vn_sizeof_VkStructureType(&pnext->sType);
9742             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9743             size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial((const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
9744             return size;
9745         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
9746             if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
9747                 break;
9748             size += vn_sizeof_simple_pointer(pnext);
9749             size += vn_sizeof_VkStructureType(&pnext->sType);
9750             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9751             size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
9752             return size;
9753         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
9754             if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
9755                 break;
9756             size += vn_sizeof_simple_pointer(pnext);
9757             size += vn_sizeof_VkStructureType(&pnext->sType);
9758             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9759             size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
9760             return size;
9761         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
9762             if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
9763                 break;
9764             size += vn_sizeof_simple_pointer(pnext);
9765             size += vn_sizeof_VkStructureType(&pnext->sType);
9766             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9767             size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
9768             return size;
9769         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
9770             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
9771                 break;
9772             size += vn_sizeof_simple_pointer(pnext);
9773             size += vn_sizeof_VkStructureType(&pnext->sType);
9774             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9775             size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial((const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
9776             return size;
9777         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
9778             if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
9779                 break;
9780             size += vn_sizeof_simple_pointer(pnext);
9781             size += vn_sizeof_VkStructureType(&pnext->sType);
9782             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9783             size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self_partial((const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
9784             return size;
9785         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
9786             if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
9787                 break;
9788             size += vn_sizeof_simple_pointer(pnext);
9789             size += vn_sizeof_VkStructureType(&pnext->sType);
9790             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9791             size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
9792             return size;
9793         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
9794             if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
9795                 break;
9796             size += vn_sizeof_simple_pointer(pnext);
9797             size += vn_sizeof_VkStructureType(&pnext->sType);
9798             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9799             size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
9800             return size;
9801         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
9802             if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
9803                 break;
9804             size += vn_sizeof_simple_pointer(pnext);
9805             size += vn_sizeof_VkStructureType(&pnext->sType);
9806             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9807             size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self_partial((const VkPhysicalDeviceSynchronization2Features *)pnext);
9808             return size;
9809         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
9810             if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
9811                 break;
9812             size += vn_sizeof_simple_pointer(pnext);
9813             size += vn_sizeof_VkStructureType(&pnext->sType);
9814             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9815             size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
9816             return size;
9817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
9818             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
9819                 break;
9820             size += vn_sizeof_simple_pointer(pnext);
9821             size += vn_sizeof_VkStructureType(&pnext->sType);
9822             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9823             size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial((const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
9824             return size;
9825         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
9826             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
9827                 break;
9828             size += vn_sizeof_simple_pointer(pnext);
9829             size += vn_sizeof_VkStructureType(&pnext->sType);
9830             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9831             size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
9832             return size;
9833         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
9834             if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
9835                 break;
9836             size += vn_sizeof_simple_pointer(pnext);
9837             size += vn_sizeof_VkStructureType(&pnext->sType);
9838             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9839             size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self_partial((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
9840             return size;
9841         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
9842             if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
9843                 break;
9844             size += vn_sizeof_simple_pointer(pnext);
9845             size += vn_sizeof_VkStructureType(&pnext->sType);
9846             size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
9847             size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial((const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
9848             return size;
9849         default:
9850             /* ignore unknown/unsupported struct */
9851             break;
9852         }
9853         pnext = pnext->pNext;
9854     }
9855 
9856     return vn_sizeof_simple_pointer(NULL);
9857 }
9858 
9859 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 * val)9860 vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(const VkPhysicalDeviceFeatures2 *val)
9861 {
9862     size_t size = 0;
9863     /* skip val->{sType,pNext} */
9864     size += vn_sizeof_VkPhysicalDeviceFeatures_partial(&val->features);
9865     return size;
9866 }
9867 
9868 static inline size_t
vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 * val)9869 vn_sizeof_VkPhysicalDeviceFeatures2_partial(const VkPhysicalDeviceFeatures2 *val)
9870 {
9871     size_t size = 0;
9872 
9873     size += vn_sizeof_VkStructureType(&val->sType);
9874     size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(val->pNext);
9875     size += vn_sizeof_VkPhysicalDeviceFeatures2_self_partial(val);
9876 
9877     return size;
9878 }
9879 
9880 static inline void
vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder * enc,const void * val)9881 vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
9882 {
9883     const VkBaseInStructure *pnext = val;
9884 
9885     while (pnext) {
9886         switch ((int32_t)pnext->sType) {
9887         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
9888             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
9889                 break;
9890             vn_encode_simple_pointer(enc, pnext);
9891             vn_encode_VkStructureType(enc, &pnext->sType);
9892             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9893             vn_encode_VkPhysicalDevicePrivateDataFeatures_self_partial(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext);
9894             return;
9895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
9896             vn_encode_simple_pointer(enc, pnext);
9897             vn_encode_VkStructureType(enc, &pnext->sType);
9898             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9899             vn_encode_VkPhysicalDeviceVariablePointersFeatures_self_partial(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
9900             return;
9901         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
9902             vn_encode_simple_pointer(enc, pnext);
9903             vn_encode_VkStructureType(enc, &pnext->sType);
9904             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9905             vn_encode_VkPhysicalDeviceMultiviewFeatures_self_partial(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
9906             return;
9907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
9908             vn_encode_simple_pointer(enc, pnext);
9909             vn_encode_VkStructureType(enc, &pnext->sType);
9910             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9911             vn_encode_VkPhysicalDevice16BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
9912             return;
9913         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
9914             vn_encode_simple_pointer(enc, pnext);
9915             vn_encode_VkStructureType(enc, &pnext->sType);
9916             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9917             vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self_partial(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
9918             return;
9919         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
9920             vn_encode_simple_pointer(enc, pnext);
9921             vn_encode_VkStructureType(enc, &pnext->sType);
9922             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9923             vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self_partial(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
9924             return;
9925         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
9926             vn_encode_simple_pointer(enc, pnext);
9927             vn_encode_VkStructureType(enc, &pnext->sType);
9928             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9929             vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
9930             return;
9931         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
9932             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
9933                 break;
9934             vn_encode_simple_pointer(enc, pnext);
9935             vn_encode_VkStructureType(enc, &pnext->sType);
9936             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9937             vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self_partial(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
9938             return;
9939         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
9940             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
9941                 break;
9942             vn_encode_simple_pointer(enc, pnext);
9943             vn_encode_VkStructureType(enc, &pnext->sType);
9944             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9945             vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
9946             return;
9947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
9948             vn_encode_simple_pointer(enc, pnext);
9949             vn_encode_VkStructureType(enc, &pnext->sType);
9950             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9951             vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
9952             return;
9953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
9954             vn_encode_simple_pointer(enc, pnext);
9955             vn_encode_VkStructureType(enc, &pnext->sType);
9956             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9957             vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self_partial(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
9958             return;
9959         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
9960             vn_encode_simple_pointer(enc, pnext);
9961             vn_encode_VkStructureType(enc, &pnext->sType);
9962             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9963             vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self_partial(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
9964             return;
9965         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
9966             vn_encode_simple_pointer(enc, pnext);
9967             vn_encode_VkStructureType(enc, &pnext->sType);
9968             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9969             vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
9970             return;
9971         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
9972             vn_encode_simple_pointer(enc, pnext);
9973             vn_encode_VkStructureType(enc, &pnext->sType);
9974             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9975             vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
9976             return;
9977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
9978             vn_encode_simple_pointer(enc, pnext);
9979             vn_encode_VkStructureType(enc, &pnext->sType);
9980             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9981             vn_encode_VkPhysicalDevice8BitStorageFeatures_self_partial(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
9982             return;
9983         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
9984             if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
9985                 break;
9986             vn_encode_simple_pointer(enc, pnext);
9987             vn_encode_VkStructureType(enc, &pnext->sType);
9988             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9989             vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
9990             return;
9991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
9992             vn_encode_simple_pointer(enc, pnext);
9993             vn_encode_VkStructureType(enc, &pnext->sType);
9994             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
9995             vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self_partial(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
9996             return;
9997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
9998             vn_encode_simple_pointer(enc, pnext);
9999             vn_encode_VkStructureType(enc, &pnext->sType);
10000             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10001             vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self_partial(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
10002             return;
10003         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
10004             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
10005                 break;
10006             vn_encode_simple_pointer(enc, pnext);
10007             vn_encode_VkStructureType(enc, &pnext->sType);
10008             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10009             vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
10010             return;
10011         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
10012             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
10013                 break;
10014             vn_encode_simple_pointer(enc, pnext);
10015             vn_encode_VkStructureType(enc, &pnext->sType);
10016             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10017             vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
10018             return;
10019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
10020             vn_encode_simple_pointer(enc, pnext);
10021             vn_encode_VkStructureType(enc, &pnext->sType);
10022             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10023             vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
10024             return;
10025         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
10026             vn_encode_simple_pointer(enc, pnext);
10027             vn_encode_VkStructureType(enc, &pnext->sType);
10028             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10029             vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self_partial(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
10030             return;
10031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
10032             if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
10033                 break;
10034             vn_encode_simple_pointer(enc, pnext);
10035             vn_encode_VkStructureType(enc, &pnext->sType);
10036             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10037             vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
10038             return;
10039         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
10040             vn_encode_simple_pointer(enc, pnext);
10041             vn_encode_VkStructureType(enc, &pnext->sType);
10042             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10043             vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self_partial(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
10044             return;
10045         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
10046             vn_encode_simple_pointer(enc, pnext);
10047             vn_encode_VkStructureType(enc, &pnext->sType);
10048             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10049             vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self_partial(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
10050             return;
10051         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
10052             if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
10053                 break;
10054             vn_encode_simple_pointer(enc, pnext);
10055             vn_encode_VkStructureType(enc, &pnext->sType);
10056             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10057             vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self_partial(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
10058             return;
10059         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
10060             if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
10061                 break;
10062             vn_encode_simple_pointer(enc, pnext);
10063             vn_encode_VkStructureType(enc, &pnext->sType);
10064             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10065             vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
10066             return;
10067         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
10068             vn_encode_simple_pointer(enc, pnext);
10069             vn_encode_VkStructureType(enc, &pnext->sType);
10070             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10071             vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self_partial(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
10072             return;
10073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
10074             if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
10075                 break;
10076             vn_encode_simple_pointer(enc, pnext);
10077             vn_encode_VkStructureType(enc, &pnext->sType);
10078             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10079             vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self_partial(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
10080             return;
10081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
10082             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
10083                 break;
10084             vn_encode_simple_pointer(enc, pnext);
10085             vn_encode_VkStructureType(enc, &pnext->sType);
10086             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10087             vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
10088             return;
10089         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
10090             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
10091                 break;
10092             vn_encode_simple_pointer(enc, pnext);
10093             vn_encode_VkStructureType(enc, &pnext->sType);
10094             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10095             vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self_partial(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
10096             return;
10097         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
10098             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
10099                 break;
10100             vn_encode_simple_pointer(enc, pnext);
10101             vn_encode_VkStructureType(enc, &pnext->sType);
10102             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10103             vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
10104             return;
10105         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
10106             if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
10107                 break;
10108             vn_encode_simple_pointer(enc, pnext);
10109             vn_encode_VkStructureType(enc, &pnext->sType);
10110             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10111             vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self_partial(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
10112             return;
10113         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
10114             vn_encode_simple_pointer(enc, pnext);
10115             vn_encode_VkStructureType(enc, &pnext->sType);
10116             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10117             vn_encode_VkPhysicalDeviceVulkan11Features_self_partial(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
10118             return;
10119         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
10120             vn_encode_simple_pointer(enc, pnext);
10121             vn_encode_VkStructureType(enc, &pnext->sType);
10122             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10123             vn_encode_VkPhysicalDeviceVulkan12Features_self_partial(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
10124             return;
10125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
10126             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
10127                 break;
10128             vn_encode_simple_pointer(enc, pnext);
10129             vn_encode_VkStructureType(enc, &pnext->sType);
10130             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10131             vn_encode_VkPhysicalDeviceVulkan13Features_self_partial(enc, (const VkPhysicalDeviceVulkan13Features *)pnext);
10132             return;
10133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
10134             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
10135                 break;
10136             vn_encode_simple_pointer(enc, pnext);
10137             vn_encode_VkStructureType(enc, &pnext->sType);
10138             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10139             vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
10140             return;
10141         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
10142             if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
10143                 break;
10144             vn_encode_simple_pointer(enc, pnext);
10145             vn_encode_VkStructureType(enc, &pnext->sType);
10146             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10147             vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
10148             return;
10149         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
10150             if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
10151                 break;
10152             vn_encode_simple_pointer(enc, pnext);
10153             vn_encode_VkStructureType(enc, &pnext->sType);
10154             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10155             vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
10156             return;
10157         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
10158             if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
10159                 break;
10160             vn_encode_simple_pointer(enc, pnext);
10161             vn_encode_VkStructureType(enc, &pnext->sType);
10162             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10163             vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self_partial(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
10164             return;
10165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
10166             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
10167                 break;
10168             vn_encode_simple_pointer(enc, pnext);
10169             vn_encode_VkStructureType(enc, &pnext->sType);
10170             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10171             vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self_partial(enc, (const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
10172             return;
10173         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
10174             if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
10175                 break;
10176             vn_encode_simple_pointer(enc, pnext);
10177             vn_encode_VkStructureType(enc, &pnext->sType);
10178             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10179             vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self_partial(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
10180             return;
10181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
10182             if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
10183                 break;
10184             vn_encode_simple_pointer(enc, pnext);
10185             vn_encode_VkStructureType(enc, &pnext->sType);
10186             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10187             vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self_partial(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
10188             return;
10189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
10190             if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
10191                 break;
10192             vn_encode_simple_pointer(enc, pnext);
10193             vn_encode_VkStructureType(enc, &pnext->sType);
10194             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10195             vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self_partial(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
10196             return;
10197         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
10198             if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
10199                 break;
10200             vn_encode_simple_pointer(enc, pnext);
10201             vn_encode_VkStructureType(enc, &pnext->sType);
10202             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10203             vn_encode_VkPhysicalDeviceSynchronization2Features_self_partial(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext);
10204             return;
10205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
10206             if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
10207                 break;
10208             vn_encode_simple_pointer(enc, pnext);
10209             vn_encode_VkStructureType(enc, &pnext->sType);
10210             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10211             vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
10212             return;
10213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
10214             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
10215                 break;
10216             vn_encode_simple_pointer(enc, pnext);
10217             vn_encode_VkStructureType(enc, &pnext->sType);
10218             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10219             vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
10220             return;
10221         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
10222             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
10223                 break;
10224             vn_encode_simple_pointer(enc, pnext);
10225             vn_encode_VkStructureType(enc, &pnext->sType);
10226             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10227             vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self_partial(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
10228             return;
10229         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
10230             if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
10231                 break;
10232             vn_encode_simple_pointer(enc, pnext);
10233             vn_encode_VkStructureType(enc, &pnext->sType);
10234             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10235             vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self_partial(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
10236             return;
10237         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
10238             if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
10239                 break;
10240             vn_encode_simple_pointer(enc, pnext);
10241             vn_encode_VkStructureType(enc, &pnext->sType);
10242             vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
10243             vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self_partial(enc, (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
10244             return;
10245         default:
10246             /* ignore unknown/unsupported struct */
10247             break;
10248         }
10249         pnext = pnext->pNext;
10250     }
10251 
10252     vn_encode_simple_pointer(enc, NULL);
10253 }
10254 
10255 static inline void
vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)10256 vn_encode_VkPhysicalDeviceFeatures2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
10257 {
10258     /* skip val->{sType,pNext} */
10259     vn_encode_VkPhysicalDeviceFeatures_partial(enc, &val->features);
10260 }
10261 
10262 static inline void
vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFeatures2 * val)10263 vn_encode_VkPhysicalDeviceFeatures2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFeatures2 *val)
10264 {
10265     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
10266     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 });
10267     vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, val->pNext);
10268     vn_encode_VkPhysicalDeviceFeatures2_self_partial(enc, val);
10269 }
10270 
10271 /* struct VkDeviceGroupDeviceCreateInfo chain */
10272 
10273 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void * val)10274 vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(const void *val)
10275 {
10276     /* no known/supported struct */
10277     return vn_sizeof_simple_pointer(NULL);
10278 }
10279 
10280 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo * val)10281 vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(const VkDeviceGroupDeviceCreateInfo *val)
10282 {
10283     size_t size = 0;
10284     /* skip val->{sType,pNext} */
10285     size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
10286     if (val->pPhysicalDevices) {
10287         size += vn_sizeof_array_size(val->physicalDeviceCount);
10288         for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
10289             size += vn_sizeof_VkPhysicalDevice(&val->pPhysicalDevices[i]);
10290     } else {
10291         size += vn_sizeof_array_size(0);
10292     }
10293     return size;
10294 }
10295 
10296 static inline size_t
vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo * val)10297 vn_sizeof_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo *val)
10298 {
10299     size_t size = 0;
10300 
10301     size += vn_sizeof_VkStructureType(&val->sType);
10302     size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_pnext(val->pNext);
10303     size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self(val);
10304 
10305     return size;
10306 }
10307 
10308 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)10309 vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10310 {
10311     /* no known/supported struct */
10312     vn_encode_simple_pointer(enc, NULL);
10313 }
10314 
10315 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)10316 vn_encode_VkDeviceGroupDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
10317 {
10318     /* skip val->{sType,pNext} */
10319     vn_encode_uint32_t(enc, &val->physicalDeviceCount);
10320     if (val->pPhysicalDevices) {
10321         vn_encode_array_size(enc, val->physicalDeviceCount);
10322         for (uint32_t i = 0; i < val->physicalDeviceCount; i++)
10323             vn_encode_VkPhysicalDevice(enc, &val->pPhysicalDevices[i]);
10324     } else {
10325         vn_encode_array_size(enc, 0);
10326     }
10327 }
10328 
10329 static inline void
vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceGroupDeviceCreateInfo * val)10330 vn_encode_VkDeviceGroupDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceGroupDeviceCreateInfo *val)
10331 {
10332     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
10333     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO });
10334     vn_encode_VkDeviceGroupDeviceCreateInfo_pnext(enc, val->pNext);
10335     vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, val);
10336 }
10337 
10338 /* struct VkDeviceCreateInfo chain */
10339 
10340 static inline size_t
vn_sizeof_VkDeviceCreateInfo_pnext(const void * val)10341 vn_sizeof_VkDeviceCreateInfo_pnext(const void *val)
10342 {
10343     const VkBaseInStructure *pnext = val;
10344     size_t size = 0;
10345 
10346     while (pnext) {
10347         switch ((int32_t)pnext->sType) {
10348         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
10349             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
10350                 break;
10351             size += vn_sizeof_simple_pointer(pnext);
10352             size += vn_sizeof_VkStructureType(&pnext->sType);
10353             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10354             size += vn_sizeof_VkDevicePrivateDataCreateInfo_self((const VkDevicePrivateDataCreateInfo *)pnext);
10355             return size;
10356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
10357             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
10358                 break;
10359             size += vn_sizeof_simple_pointer(pnext);
10360             size += vn_sizeof_VkStructureType(&pnext->sType);
10361             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10362             size += vn_sizeof_VkPhysicalDevicePrivateDataFeatures_self((const VkPhysicalDevicePrivateDataFeatures *)pnext);
10363             return size;
10364         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
10365             size += vn_sizeof_simple_pointer(pnext);
10366             size += vn_sizeof_VkStructureType(&pnext->sType);
10367             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10368             size += vn_sizeof_VkPhysicalDeviceFeatures2_self((const VkPhysicalDeviceFeatures2 *)pnext);
10369             return size;
10370         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
10371             size += vn_sizeof_simple_pointer(pnext);
10372             size += vn_sizeof_VkStructureType(&pnext->sType);
10373             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10374             size += vn_sizeof_VkPhysicalDeviceVariablePointersFeatures_self((const VkPhysicalDeviceVariablePointersFeatures *)pnext);
10375             return size;
10376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
10377             size += vn_sizeof_simple_pointer(pnext);
10378             size += vn_sizeof_VkStructureType(&pnext->sType);
10379             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10380             size += vn_sizeof_VkPhysicalDeviceMultiviewFeatures_self((const VkPhysicalDeviceMultiviewFeatures *)pnext);
10381             return size;
10382         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
10383             size += vn_sizeof_simple_pointer(pnext);
10384             size += vn_sizeof_VkStructureType(&pnext->sType);
10385             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10386             size += vn_sizeof_VkDeviceGroupDeviceCreateInfo_self((const VkDeviceGroupDeviceCreateInfo *)pnext);
10387             return size;
10388         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
10389             size += vn_sizeof_simple_pointer(pnext);
10390             size += vn_sizeof_VkStructureType(&pnext->sType);
10391             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10392             size += vn_sizeof_VkPhysicalDevice16BitStorageFeatures_self((const VkPhysicalDevice16BitStorageFeatures *)pnext);
10393             return size;
10394         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
10395             size += vn_sizeof_simple_pointer(pnext);
10396             size += vn_sizeof_VkStructureType(&pnext->sType);
10397             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10398             size += vn_sizeof_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self((const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
10399             return size;
10400         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
10401             size += vn_sizeof_simple_pointer(pnext);
10402             size += vn_sizeof_VkStructureType(&pnext->sType);
10403             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10404             size += vn_sizeof_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self((const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
10405             return size;
10406         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
10407             size += vn_sizeof_simple_pointer(pnext);
10408             size += vn_sizeof_VkStructureType(&pnext->sType);
10409             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10410             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryFeatures_self((const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
10411             return size;
10412         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
10413             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
10414                 break;
10415             size += vn_sizeof_simple_pointer(pnext);
10416             size += vn_sizeof_VkStructureType(&pnext->sType);
10417             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10418             size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockFeatures_self((const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
10419             return size;
10420         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
10421             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
10422                 break;
10423             size += vn_sizeof_simple_pointer(pnext);
10424             size += vn_sizeof_VkStructureType(&pnext->sType);
10425             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10426             size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext);
10427             return size;
10428         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
10429             size += vn_sizeof_simple_pointer(pnext);
10430             size += vn_sizeof_VkStructureType(&pnext->sType);
10431             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10432             size += vn_sizeof_VkPhysicalDeviceShaderDrawParametersFeatures_self((const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
10433             return size;
10434         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
10435             size += vn_sizeof_simple_pointer(pnext);
10436             size += vn_sizeof_VkStructureType(&pnext->sType);
10437             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10438             size += vn_sizeof_VkPhysicalDeviceShaderFloat16Int8Features_self((const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
10439             return size;
10440         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
10441             size += vn_sizeof_simple_pointer(pnext);
10442             size += vn_sizeof_VkStructureType(&pnext->sType);
10443             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10444             size += vn_sizeof_VkPhysicalDeviceHostQueryResetFeatures_self((const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
10445             return size;
10446         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
10447             size += vn_sizeof_simple_pointer(pnext);
10448             size += vn_sizeof_VkStructureType(&pnext->sType);
10449             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10450             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingFeatures_self((const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
10451             return size;
10452         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
10453             size += vn_sizeof_simple_pointer(pnext);
10454             size += vn_sizeof_VkStructureType(&pnext->sType);
10455             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10456             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreFeatures_self((const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
10457             return size;
10458         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
10459             size += vn_sizeof_simple_pointer(pnext);
10460             size += vn_sizeof_VkStructureType(&pnext->sType);
10461             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10462             size += vn_sizeof_VkPhysicalDevice8BitStorageFeatures_self((const VkPhysicalDevice8BitStorageFeatures *)pnext);
10463             return size;
10464         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
10465             if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
10466                 break;
10467             size += vn_sizeof_simple_pointer(pnext);
10468             size += vn_sizeof_VkStructureType(&pnext->sType);
10469             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10470             size += vn_sizeof_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self((const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
10471             return size;
10472         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
10473             size += vn_sizeof_simple_pointer(pnext);
10474             size += vn_sizeof_VkStructureType(&pnext->sType);
10475             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10476             size += vn_sizeof_VkPhysicalDeviceVulkanMemoryModelFeatures_self((const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
10477             return size;
10478         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
10479             size += vn_sizeof_simple_pointer(pnext);
10480             size += vn_sizeof_VkStructureType(&pnext->sType);
10481             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10482             size += vn_sizeof_VkPhysicalDeviceShaderAtomicInt64Features_self((const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
10483             return size;
10484         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
10485             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
10486                 break;
10487             size += vn_sizeof_simple_pointer(pnext);
10488             size += vn_sizeof_VkStructureType(&pnext->sType);
10489             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10490             size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self((const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
10491             return size;
10492         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
10493             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
10494                 break;
10495             size += vn_sizeof_simple_pointer(pnext);
10496             size += vn_sizeof_VkStructureType(&pnext->sType);
10497             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10498             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self((const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
10499             return size;
10500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
10501             size += vn_sizeof_simple_pointer(pnext);
10502             size += vn_sizeof_VkStructureType(&pnext->sType);
10503             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10504             size += vn_sizeof_VkPhysicalDeviceScalarBlockLayoutFeatures_self((const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
10505             return size;
10506         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
10507             size += vn_sizeof_simple_pointer(pnext);
10508             size += vn_sizeof_VkStructureType(&pnext->sType);
10509             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10510             size += vn_sizeof_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self((const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
10511             return size;
10512         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
10513             if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
10514                 break;
10515             size += vn_sizeof_simple_pointer(pnext);
10516             size += vn_sizeof_VkStructureType(&pnext->sType);
10517             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10518             size += vn_sizeof_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self((const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
10519             return size;
10520         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
10521             size += vn_sizeof_simple_pointer(pnext);
10522             size += vn_sizeof_VkStructureType(&pnext->sType);
10523             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10524             size += vn_sizeof_VkPhysicalDeviceBufferDeviceAddressFeatures_self((const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
10525             return size;
10526         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
10527             size += vn_sizeof_simple_pointer(pnext);
10528             size += vn_sizeof_VkStructureType(&pnext->sType);
10529             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10530             size += vn_sizeof_VkPhysicalDeviceImagelessFramebufferFeatures_self((const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
10531             return size;
10532         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
10533             if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
10534                 break;
10535             size += vn_sizeof_simple_pointer(pnext);
10536             size += vn_sizeof_VkStructureType(&pnext->sType);
10537             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10538             size += vn_sizeof_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self((const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
10539             return size;
10540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
10541             if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
10542                 break;
10543             size += vn_sizeof_simple_pointer(pnext);
10544             size += vn_sizeof_VkStructureType(&pnext->sType);
10545             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10546             size += vn_sizeof_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self((const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
10547             return size;
10548         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
10549             size += vn_sizeof_simple_pointer(pnext);
10550             size += vn_sizeof_VkStructureType(&pnext->sType);
10551             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10552             size += vn_sizeof_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self((const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
10553             return size;
10554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
10555             if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
10556                 break;
10557             size += vn_sizeof_simple_pointer(pnext);
10558             size += vn_sizeof_VkStructureType(&pnext->sType);
10559             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10560             size += vn_sizeof_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self((const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
10561             return size;
10562         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
10563             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
10564                 break;
10565             size += vn_sizeof_simple_pointer(pnext);
10566             size += vn_sizeof_VkStructureType(&pnext->sType);
10567             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10568             size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self((const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
10569             return size;
10570         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
10571             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
10572                 break;
10573             size += vn_sizeof_simple_pointer(pnext);
10574             size += vn_sizeof_VkStructureType(&pnext->sType);
10575             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10576             size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlFeatures_self((const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
10577             return size;
10578         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
10579             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
10580                 break;
10581             size += vn_sizeof_simple_pointer(pnext);
10582             size += vn_sizeof_VkStructureType(&pnext->sType);
10583             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10584             size += vn_sizeof_VkPhysicalDeviceLineRasterizationFeaturesEXT_self((const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
10585             return size;
10586         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
10587             if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
10588                 break;
10589             size += vn_sizeof_simple_pointer(pnext);
10590             size += vn_sizeof_VkStructureType(&pnext->sType);
10591             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10592             size += vn_sizeof_VkPhysicalDevicePipelineCreationCacheControlFeatures_self((const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
10593             return size;
10594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
10595             size += vn_sizeof_simple_pointer(pnext);
10596             size += vn_sizeof_VkStructureType(&pnext->sType);
10597             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10598             size += vn_sizeof_VkPhysicalDeviceVulkan11Features_self((const VkPhysicalDeviceVulkan11Features *)pnext);
10599             return size;
10600         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
10601             size += vn_sizeof_simple_pointer(pnext);
10602             size += vn_sizeof_VkStructureType(&pnext->sType);
10603             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10604             size += vn_sizeof_VkPhysicalDeviceVulkan12Features_self((const VkPhysicalDeviceVulkan12Features *)pnext);
10605             return size;
10606         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
10607             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
10608                 break;
10609             size += vn_sizeof_simple_pointer(pnext);
10610             size += vn_sizeof_VkStructureType(&pnext->sType);
10611             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10612             size += vn_sizeof_VkPhysicalDeviceVulkan13Features_self((const VkPhysicalDeviceVulkan13Features *)pnext);
10613             return size;
10614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
10615             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
10616                 break;
10617             size += vn_sizeof_simple_pointer(pnext);
10618             size += vn_sizeof_VkStructureType(&pnext->sType);
10619             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10620             size += vn_sizeof_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self((const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
10621             return size;
10622         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
10623             if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
10624                 break;
10625             size += vn_sizeof_simple_pointer(pnext);
10626             size += vn_sizeof_VkStructureType(&pnext->sType);
10627             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10628             size += vn_sizeof_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
10629             return size;
10630         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
10631             if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
10632                 break;
10633             size += vn_sizeof_simple_pointer(pnext);
10634             size += vn_sizeof_VkStructureType(&pnext->sType);
10635             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10636             size += vn_sizeof_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self((const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
10637             return size;
10638         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
10639             if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
10640                 break;
10641             size += vn_sizeof_simple_pointer(pnext);
10642             size += vn_sizeof_VkStructureType(&pnext->sType);
10643             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10644             size += vn_sizeof_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self((const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
10645             return size;
10646         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
10647             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
10648                 break;
10649             size += vn_sizeof_simple_pointer(pnext);
10650             size += vn_sizeof_VkStructureType(&pnext->sType);
10651             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10652             size += vn_sizeof_VkPhysicalDeviceRobustness2FeaturesEXT_self((const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
10653             return size;
10654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
10655             if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
10656                 break;
10657             size += vn_sizeof_simple_pointer(pnext);
10658             size += vn_sizeof_VkStructureType(&pnext->sType);
10659             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10660             size += vn_sizeof_VkPhysicalDeviceImageRobustnessFeatures_self((const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
10661             return size;
10662         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
10663             if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
10664                 break;
10665             size += vn_sizeof_simple_pointer(pnext);
10666             size += vn_sizeof_VkStructureType(&pnext->sType);
10667             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10668             size += vn_sizeof_VkPhysicalDevice4444FormatsFeaturesEXT_self((const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
10669             return size;
10670         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
10671             if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
10672                 break;
10673             size += vn_sizeof_simple_pointer(pnext);
10674             size += vn_sizeof_VkStructureType(&pnext->sType);
10675             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10676             size += vn_sizeof_VkPhysicalDeviceShaderTerminateInvocationFeatures_self((const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
10677             return size;
10678         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
10679             if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
10680                 break;
10681             size += vn_sizeof_simple_pointer(pnext);
10682             size += vn_sizeof_VkStructureType(&pnext->sType);
10683             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10684             size += vn_sizeof_VkPhysicalDeviceSynchronization2Features_self((const VkPhysicalDeviceSynchronization2Features *)pnext);
10685             return size;
10686         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
10687             if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
10688                 break;
10689             size += vn_sizeof_simple_pointer(pnext);
10690             size += vn_sizeof_VkStructureType(&pnext->sType);
10691             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10692             size += vn_sizeof_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self((const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
10693             return size;
10694         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
10695             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
10696                 break;
10697             size += vn_sizeof_simple_pointer(pnext);
10698             size += vn_sizeof_VkStructureType(&pnext->sType);
10699             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10700             size += vn_sizeof_VkPhysicalDeviceProvokingVertexFeaturesEXT_self((const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
10701             return size;
10702         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
10703             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
10704                 break;
10705             size += vn_sizeof_simple_pointer(pnext);
10706             size += vn_sizeof_VkStructureType(&pnext->sType);
10707             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10708             size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductFeatures_self((const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
10709             return size;
10710         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
10711             if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
10712                 break;
10713             size += vn_sizeof_simple_pointer(pnext);
10714             size += vn_sizeof_VkStructureType(&pnext->sType);
10715             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10716             size += vn_sizeof_VkPhysicalDeviceDynamicRenderingFeatures_self((const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
10717             return size;
10718         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
10719             if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
10720                 break;
10721             size += vn_sizeof_simple_pointer(pnext);
10722             size += vn_sizeof_VkStructureType(&pnext->sType);
10723             size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
10724             size += vn_sizeof_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self((const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
10725             return size;
10726         default:
10727             /* ignore unknown/unsupported struct */
10728             break;
10729         }
10730         pnext = pnext->pNext;
10731     }
10732 
10733     return vn_sizeof_simple_pointer(NULL);
10734 }
10735 
10736 static inline size_t
vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo * val)10737 vn_sizeof_VkDeviceCreateInfo_self(const VkDeviceCreateInfo *val)
10738 {
10739     size_t size = 0;
10740     /* skip val->{sType,pNext} */
10741     size += vn_sizeof_VkFlags(&val->flags);
10742     size += vn_sizeof_uint32_t(&val->queueCreateInfoCount);
10743     if (val->pQueueCreateInfos) {
10744         size += vn_sizeof_array_size(val->queueCreateInfoCount);
10745         for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
10746             size += vn_sizeof_VkDeviceQueueCreateInfo(&val->pQueueCreateInfos[i]);
10747     } else {
10748         size += vn_sizeof_array_size(0);
10749     }
10750     size += vn_sizeof_uint32_t(&val->enabledLayerCount);
10751     if (val->ppEnabledLayerNames) {
10752         size += vn_sizeof_array_size(val->enabledLayerCount);
10753         for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
10754             const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
10755             size += vn_sizeof_array_size(string_size);
10756             size += vn_sizeof_char_array(val->ppEnabledLayerNames[i], string_size);
10757         }
10758     } else {
10759         size += vn_sizeof_array_size(0);
10760     }
10761     size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
10762     if (val->ppEnabledExtensionNames) {
10763         size += vn_sizeof_array_size(val->enabledExtensionCount);
10764         for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
10765             const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
10766             size += vn_sizeof_array_size(string_size);
10767             size += vn_sizeof_char_array(val->ppEnabledExtensionNames[i], string_size);
10768         }
10769     } else {
10770         size += vn_sizeof_array_size(0);
10771     }
10772     size += vn_sizeof_simple_pointer(val->pEnabledFeatures);
10773     if (val->pEnabledFeatures)
10774         size += vn_sizeof_VkPhysicalDeviceFeatures(val->pEnabledFeatures);
10775     return size;
10776 }
10777 
10778 static inline size_t
vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo * val)10779 vn_sizeof_VkDeviceCreateInfo(const VkDeviceCreateInfo *val)
10780 {
10781     size_t size = 0;
10782 
10783     size += vn_sizeof_VkStructureType(&val->sType);
10784     size += vn_sizeof_VkDeviceCreateInfo_pnext(val->pNext);
10785     size += vn_sizeof_VkDeviceCreateInfo_self(val);
10786 
10787     return size;
10788 }
10789 
10790 static inline void
vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder * enc,const void * val)10791 vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
10792 {
10793     const VkBaseInStructure *pnext = val;
10794 
10795     while (pnext) {
10796         switch ((int32_t)pnext->sType) {
10797         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
10798             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
10799                 break;
10800             vn_encode_simple_pointer(enc, pnext);
10801             vn_encode_VkStructureType(enc, &pnext->sType);
10802             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10803             vn_encode_VkDevicePrivateDataCreateInfo_self(enc, (const VkDevicePrivateDataCreateInfo *)pnext);
10804             return;
10805         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
10806             if (!vn_cs_renderer_protocol_has_extension(296 /* VK_EXT_private_data */))
10807                 break;
10808             vn_encode_simple_pointer(enc, pnext);
10809             vn_encode_VkStructureType(enc, &pnext->sType);
10810             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10811             vn_encode_VkPhysicalDevicePrivateDataFeatures_self(enc, (const VkPhysicalDevicePrivateDataFeatures *)pnext);
10812             return;
10813         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
10814             vn_encode_simple_pointer(enc, pnext);
10815             vn_encode_VkStructureType(enc, &pnext->sType);
10816             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10817             vn_encode_VkPhysicalDeviceFeatures2_self(enc, (const VkPhysicalDeviceFeatures2 *)pnext);
10818             return;
10819         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
10820             vn_encode_simple_pointer(enc, pnext);
10821             vn_encode_VkStructureType(enc, &pnext->sType);
10822             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10823             vn_encode_VkPhysicalDeviceVariablePointersFeatures_self(enc, (const VkPhysicalDeviceVariablePointersFeatures *)pnext);
10824             return;
10825         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
10826             vn_encode_simple_pointer(enc, pnext);
10827             vn_encode_VkStructureType(enc, &pnext->sType);
10828             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10829             vn_encode_VkPhysicalDeviceMultiviewFeatures_self(enc, (const VkPhysicalDeviceMultiviewFeatures *)pnext);
10830             return;
10831         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
10832             vn_encode_simple_pointer(enc, pnext);
10833             vn_encode_VkStructureType(enc, &pnext->sType);
10834             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10835             vn_encode_VkDeviceGroupDeviceCreateInfo_self(enc, (const VkDeviceGroupDeviceCreateInfo *)pnext);
10836             return;
10837         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
10838             vn_encode_simple_pointer(enc, pnext);
10839             vn_encode_VkStructureType(enc, &pnext->sType);
10840             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10841             vn_encode_VkPhysicalDevice16BitStorageFeatures_self(enc, (const VkPhysicalDevice16BitStorageFeatures *)pnext);
10842             return;
10843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
10844             vn_encode_simple_pointer(enc, pnext);
10845             vn_encode_VkStructureType(enc, &pnext->sType);
10846             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10847             vn_encode_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures_self(enc, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)pnext);
10848             return;
10849         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
10850             vn_encode_simple_pointer(enc, pnext);
10851             vn_encode_VkStructureType(enc, &pnext->sType);
10852             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10853             vn_encode_VkPhysicalDeviceSamplerYcbcrConversionFeatures_self(enc, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)pnext);
10854             return;
10855         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
10856             vn_encode_simple_pointer(enc, pnext);
10857             vn_encode_VkStructureType(enc, &pnext->sType);
10858             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10859             vn_encode_VkPhysicalDeviceProtectedMemoryFeatures_self(enc, (const VkPhysicalDeviceProtectedMemoryFeatures *)pnext);
10860             return;
10861         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
10862             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
10863                 break;
10864             vn_encode_simple_pointer(enc, pnext);
10865             vn_encode_VkStructureType(enc, &pnext->sType);
10866             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10867             vn_encode_VkPhysicalDeviceInlineUniformBlockFeatures_self(enc, (const VkPhysicalDeviceInlineUniformBlockFeatures *)pnext);
10868             return;
10869         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
10870             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
10871                 break;
10872             vn_encode_simple_pointer(enc, pnext);
10873             vn_encode_VkStructureType(enc, &pnext->sType);
10874             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10875             vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
10876             return;
10877         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
10878             vn_encode_simple_pointer(enc, pnext);
10879             vn_encode_VkStructureType(enc, &pnext->sType);
10880             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10881             vn_encode_VkPhysicalDeviceShaderDrawParametersFeatures_self(enc, (const VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
10882             return;
10883         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
10884             vn_encode_simple_pointer(enc, pnext);
10885             vn_encode_VkStructureType(enc, &pnext->sType);
10886             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10887             vn_encode_VkPhysicalDeviceShaderFloat16Int8Features_self(enc, (const VkPhysicalDeviceShaderFloat16Int8Features *)pnext);
10888             return;
10889         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
10890             vn_encode_simple_pointer(enc, pnext);
10891             vn_encode_VkStructureType(enc, &pnext->sType);
10892             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10893             vn_encode_VkPhysicalDeviceHostQueryResetFeatures_self(enc, (const VkPhysicalDeviceHostQueryResetFeatures *)pnext);
10894             return;
10895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
10896             vn_encode_simple_pointer(enc, pnext);
10897             vn_encode_VkStructureType(enc, &pnext->sType);
10898             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10899             vn_encode_VkPhysicalDeviceDescriptorIndexingFeatures_self(enc, (const VkPhysicalDeviceDescriptorIndexingFeatures *)pnext);
10900             return;
10901         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
10902             vn_encode_simple_pointer(enc, pnext);
10903             vn_encode_VkStructureType(enc, &pnext->sType);
10904             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10905             vn_encode_VkPhysicalDeviceTimelineSemaphoreFeatures_self(enc, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)pnext);
10906             return;
10907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
10908             vn_encode_simple_pointer(enc, pnext);
10909             vn_encode_VkStructureType(enc, &pnext->sType);
10910             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10911             vn_encode_VkPhysicalDevice8BitStorageFeatures_self(enc, (const VkPhysicalDevice8BitStorageFeatures *)pnext);
10912             return;
10913         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
10914             if (!vn_cs_renderer_protocol_has_extension(82 /* VK_EXT_conditional_rendering */))
10915                 break;
10916             vn_encode_simple_pointer(enc, pnext);
10917             vn_encode_VkStructureType(enc, &pnext->sType);
10918             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10919             vn_encode_VkPhysicalDeviceConditionalRenderingFeaturesEXT_self(enc, (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)pnext);
10920             return;
10921         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
10922             vn_encode_simple_pointer(enc, pnext);
10923             vn_encode_VkStructureType(enc, &pnext->sType);
10924             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10925             vn_encode_VkPhysicalDeviceVulkanMemoryModelFeatures_self(enc, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)pnext);
10926             return;
10927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
10928             vn_encode_simple_pointer(enc, pnext);
10929             vn_encode_VkStructureType(enc, &pnext->sType);
10930             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10931             vn_encode_VkPhysicalDeviceShaderAtomicInt64Features_self(enc, (const VkPhysicalDeviceShaderAtomicInt64Features *)pnext);
10932             return;
10933         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
10934             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
10935                 break;
10936             vn_encode_simple_pointer(enc, pnext);
10937             vn_encode_VkStructureType(enc, &pnext->sType);
10938             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10939             vn_encode_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT_self(enc, (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)pnext);
10940             return;
10941         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
10942             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
10943                 break;
10944             vn_encode_simple_pointer(enc, pnext);
10945             vn_encode_VkStructureType(enc, &pnext->sType);
10946             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10947             vn_encode_VkPhysicalDeviceTransformFeedbackFeaturesEXT_self(enc, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)pnext);
10948             return;
10949         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
10950             vn_encode_simple_pointer(enc, pnext);
10951             vn_encode_VkStructureType(enc, &pnext->sType);
10952             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10953             vn_encode_VkPhysicalDeviceScalarBlockLayoutFeatures_self(enc, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)pnext);
10954             return;
10955         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
10956             vn_encode_simple_pointer(enc, pnext);
10957             vn_encode_VkStructureType(enc, &pnext->sType);
10958             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10959             vn_encode_VkPhysicalDeviceUniformBufferStandardLayoutFeatures_self(enc, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)pnext);
10960             return;
10961         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
10962             if (!vn_cs_renderer_protocol_has_extension(103 /* VK_EXT_depth_clip_enable */))
10963                 break;
10964             vn_encode_simple_pointer(enc, pnext);
10965             vn_encode_VkStructureType(enc, &pnext->sType);
10966             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10967             vn_encode_VkPhysicalDeviceDepthClipEnableFeaturesEXT_self(enc, (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)pnext);
10968             return;
10969         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
10970             vn_encode_simple_pointer(enc, pnext);
10971             vn_encode_VkStructureType(enc, &pnext->sType);
10972             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10973             vn_encode_VkPhysicalDeviceBufferDeviceAddressFeatures_self(enc, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)pnext);
10974             return;
10975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
10976             vn_encode_simple_pointer(enc, pnext);
10977             vn_encode_VkStructureType(enc, &pnext->sType);
10978             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10979             vn_encode_VkPhysicalDeviceImagelessFramebufferFeatures_self(enc, (const VkPhysicalDeviceImagelessFramebufferFeatures *)pnext);
10980             return;
10981         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
10982             if (!vn_cs_renderer_protocol_has_extension(67 /* VK_EXT_texture_compression_astc_hdr */))
10983                 break;
10984             vn_encode_simple_pointer(enc, pnext);
10985             vn_encode_VkStructureType(enc, &pnext->sType);
10986             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10987             vn_encode_VkPhysicalDeviceTextureCompressionASTCHDRFeatures_self(enc, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)pnext);
10988             return;
10989         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
10990             if (!vn_cs_renderer_protocol_has_extension(266 /* VK_EXT_index_type_uint8 */))
10991                 break;
10992             vn_encode_simple_pointer(enc, pnext);
10993             vn_encode_VkStructureType(enc, &pnext->sType);
10994             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
10995             vn_encode_VkPhysicalDeviceIndexTypeUint8FeaturesEXT_self(enc, (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)pnext);
10996             return;
10997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
10998             vn_encode_simple_pointer(enc, pnext);
10999             vn_encode_VkStructureType(enc, &pnext->sType);
11000             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11001             vn_encode_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures_self(enc, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)pnext);
11002             return;
11003         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
11004             if (!vn_cs_renderer_protocol_has_extension(277 /* VK_EXT_shader_demote_to_helper_invocation */))
11005                 break;
11006             vn_encode_simple_pointer(enc, pnext);
11007             vn_encode_VkStructureType(enc, &pnext->sType);
11008             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11009             vn_encode_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)pnext);
11010             return;
11011         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
11012             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
11013                 break;
11014             vn_encode_simple_pointer(enc, pnext);
11015             vn_encode_VkStructureType(enc, &pnext->sType);
11016             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11017             vn_encode_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT_self(enc, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)pnext);
11018             return;
11019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
11020             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
11021                 break;
11022             vn_encode_simple_pointer(enc, pnext);
11023             vn_encode_VkStructureType(enc, &pnext->sType);
11024             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11025             vn_encode_VkPhysicalDeviceSubgroupSizeControlFeatures_self(enc, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)pnext);
11026             return;
11027         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
11028             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
11029                 break;
11030             vn_encode_simple_pointer(enc, pnext);
11031             vn_encode_VkStructureType(enc, &pnext->sType);
11032             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11033             vn_encode_VkPhysicalDeviceLineRasterizationFeaturesEXT_self(enc, (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)pnext);
11034             return;
11035         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
11036             if (!vn_cs_renderer_protocol_has_extension(298 /* VK_EXT_pipeline_creation_cache_control */))
11037                 break;
11038             vn_encode_simple_pointer(enc, pnext);
11039             vn_encode_VkStructureType(enc, &pnext->sType);
11040             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11041             vn_encode_VkPhysicalDevicePipelineCreationCacheControlFeatures_self(enc, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)pnext);
11042             return;
11043         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
11044             vn_encode_simple_pointer(enc, pnext);
11045             vn_encode_VkStructureType(enc, &pnext->sType);
11046             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11047             vn_encode_VkPhysicalDeviceVulkan11Features_self(enc, (const VkPhysicalDeviceVulkan11Features *)pnext);
11048             return;
11049         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
11050             vn_encode_simple_pointer(enc, pnext);
11051             vn_encode_VkStructureType(enc, &pnext->sType);
11052             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11053             vn_encode_VkPhysicalDeviceVulkan12Features_self(enc, (const VkPhysicalDeviceVulkan12Features *)pnext);
11054             return;
11055         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
11056             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
11057                 break;
11058             vn_encode_simple_pointer(enc, pnext);
11059             vn_encode_VkStructureType(enc, &pnext->sType);
11060             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11061             vn_encode_VkPhysicalDeviceVulkan13Features_self(enc, (const VkPhysicalDeviceVulkan13Features *)pnext);
11062             return;
11063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
11064             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
11065                 break;
11066             vn_encode_simple_pointer(enc, pnext);
11067             vn_encode_VkStructureType(enc, &pnext->sType);
11068             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11069             vn_encode_VkPhysicalDeviceCustomBorderColorFeaturesEXT_self(enc, (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)pnext);
11070             return;
11071         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
11072             if (!vn_cs_renderer_protocol_has_extension(268 /* VK_EXT_extended_dynamic_state */))
11073                 break;
11074             vn_encode_simple_pointer(enc, pnext);
11075             vn_encode_VkStructureType(enc, &pnext->sType);
11076             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11077             vn_encode_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)pnext);
11078             return;
11079         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
11080             if (!vn_cs_renderer_protocol_has_extension(378 /* VK_EXT_extended_dynamic_state2 */))
11081                 break;
11082             vn_encode_simple_pointer(enc, pnext);
11083             vn_encode_VkStructureType(enc, &pnext->sType);
11084             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11085             vn_encode_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT_self(enc, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)pnext);
11086             return;
11087         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
11088             if (!vn_cs_renderer_protocol_has_extension(326 /* VK_KHR_zero_initialize_workgroup_memory */))
11089                 break;
11090             vn_encode_simple_pointer(enc, pnext);
11091             vn_encode_VkStructureType(enc, &pnext->sType);
11092             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11093             vn_encode_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures_self(enc, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)pnext);
11094             return;
11095         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
11096             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
11097                 break;
11098             vn_encode_simple_pointer(enc, pnext);
11099             vn_encode_VkStructureType(enc, &pnext->sType);
11100             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11101             vn_encode_VkPhysicalDeviceRobustness2FeaturesEXT_self(enc, (const VkPhysicalDeviceRobustness2FeaturesEXT *)pnext);
11102             return;
11103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
11104             if (!vn_cs_renderer_protocol_has_extension(336 /* VK_EXT_image_robustness */))
11105                 break;
11106             vn_encode_simple_pointer(enc, pnext);
11107             vn_encode_VkStructureType(enc, &pnext->sType);
11108             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11109             vn_encode_VkPhysicalDeviceImageRobustnessFeatures_self(enc, (const VkPhysicalDeviceImageRobustnessFeatures *)pnext);
11110             return;
11111         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
11112             if (!vn_cs_renderer_protocol_has_extension(341 /* VK_EXT_4444_formats */))
11113                 break;
11114             vn_encode_simple_pointer(enc, pnext);
11115             vn_encode_VkStructureType(enc, &pnext->sType);
11116             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11117             vn_encode_VkPhysicalDevice4444FormatsFeaturesEXT_self(enc, (const VkPhysicalDevice4444FormatsFeaturesEXT *)pnext);
11118             return;
11119         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
11120             if (!vn_cs_renderer_protocol_has_extension(216 /* VK_KHR_shader_terminate_invocation */))
11121                 break;
11122             vn_encode_simple_pointer(enc, pnext);
11123             vn_encode_VkStructureType(enc, &pnext->sType);
11124             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11125             vn_encode_VkPhysicalDeviceShaderTerminateInvocationFeatures_self(enc, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)pnext);
11126             return;
11127         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
11128             if (!vn_cs_renderer_protocol_has_extension(315 /* VK_KHR_synchronization2 */))
11129                 break;
11130             vn_encode_simple_pointer(enc, pnext);
11131             vn_encode_VkStructureType(enc, &pnext->sType);
11132             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11133             vn_encode_VkPhysicalDeviceSynchronization2Features_self(enc, (const VkPhysicalDeviceSynchronization2Features *)pnext);
11134             return;
11135         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
11136             if (!vn_cs_renderer_protocol_has_extension(331 /* VK_EXT_ycbcr_2plane_444_formats */))
11137                 break;
11138             vn_encode_simple_pointer(enc, pnext);
11139             vn_encode_VkStructureType(enc, &pnext->sType);
11140             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11141             vn_encode_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT_self(enc, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)pnext);
11142             return;
11143         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
11144             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
11145                 break;
11146             vn_encode_simple_pointer(enc, pnext);
11147             vn_encode_VkStructureType(enc, &pnext->sType);
11148             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11149             vn_encode_VkPhysicalDeviceProvokingVertexFeaturesEXT_self(enc, (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)pnext);
11150             return;
11151         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
11152             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
11153                 break;
11154             vn_encode_simple_pointer(enc, pnext);
11155             vn_encode_VkStructureType(enc, &pnext->sType);
11156             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11157             vn_encode_VkPhysicalDeviceShaderIntegerDotProductFeatures_self(enc, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)pnext);
11158             return;
11159         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
11160             if (!vn_cs_renderer_protocol_has_extension(45 /* VK_KHR_dynamic_rendering */))
11161                 break;
11162             vn_encode_simple_pointer(enc, pnext);
11163             vn_encode_VkStructureType(enc, &pnext->sType);
11164             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11165             vn_encode_VkPhysicalDeviceDynamicRenderingFeatures_self(enc, (const VkPhysicalDeviceDynamicRenderingFeatures *)pnext);
11166             return;
11167         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
11168             if (!vn_cs_renderer_protocol_has_extension(392 /* VK_EXT_image_view_min_lod */))
11169                 break;
11170             vn_encode_simple_pointer(enc, pnext);
11171             vn_encode_VkStructureType(enc, &pnext->sType);
11172             vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
11173             vn_encode_VkPhysicalDeviceImageViewMinLodFeaturesEXT_self(enc, (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)pnext);
11174             return;
11175         default:
11176             /* ignore unknown/unsupported struct */
11177             break;
11178         }
11179         pnext = pnext->pNext;
11180     }
11181 
11182     vn_encode_simple_pointer(enc, NULL);
11183 }
11184 
11185 static inline void
vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)11186 vn_encode_VkDeviceCreateInfo_self(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
11187 {
11188     /* skip val->{sType,pNext} */
11189     vn_encode_VkFlags(enc, &val->flags);
11190     vn_encode_uint32_t(enc, &val->queueCreateInfoCount);
11191     if (val->pQueueCreateInfos) {
11192         vn_encode_array_size(enc, val->queueCreateInfoCount);
11193         for (uint32_t i = 0; i < val->queueCreateInfoCount; i++)
11194             vn_encode_VkDeviceQueueCreateInfo(enc, &val->pQueueCreateInfos[i]);
11195     } else {
11196         vn_encode_array_size(enc, 0);
11197     }
11198     vn_encode_uint32_t(enc, &val->enabledLayerCount);
11199     if (val->ppEnabledLayerNames) {
11200         vn_encode_array_size(enc, val->enabledLayerCount);
11201         for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
11202             const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
11203             vn_encode_array_size(enc, string_size);
11204             vn_encode_char_array(enc, val->ppEnabledLayerNames[i], string_size);
11205         }
11206     } else {
11207         vn_encode_array_size(enc, 0);
11208     }
11209     vn_encode_uint32_t(enc, &val->enabledExtensionCount);
11210     if (val->ppEnabledExtensionNames) {
11211         vn_encode_array_size(enc, val->enabledExtensionCount);
11212         for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
11213             const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
11214             vn_encode_array_size(enc, string_size);
11215             vn_encode_char_array(enc, val->ppEnabledExtensionNames[i], string_size);
11216         }
11217     } else {
11218         vn_encode_array_size(enc, 0);
11219     }
11220     if (vn_encode_simple_pointer(enc, val->pEnabledFeatures))
11221         vn_encode_VkPhysicalDeviceFeatures(enc, val->pEnabledFeatures);
11222 }
11223 
11224 static inline void
vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder * enc,const VkDeviceCreateInfo * val)11225 vn_encode_VkDeviceCreateInfo(struct vn_cs_encoder *enc, const VkDeviceCreateInfo *val)
11226 {
11227     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
11228     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO });
11229     vn_encode_VkDeviceCreateInfo_pnext(enc, val->pNext);
11230     vn_encode_VkDeviceCreateInfo_self(enc, val);
11231 }
11232 
11233 /* struct VkConformanceVersion */
11234 
11235 static inline size_t
vn_sizeof_VkConformanceVersion(const VkConformanceVersion * val)11236 vn_sizeof_VkConformanceVersion(const VkConformanceVersion *val)
11237 {
11238     size_t size = 0;
11239     size += vn_sizeof_uint8_t(&val->major);
11240     size += vn_sizeof_uint8_t(&val->minor);
11241     size += vn_sizeof_uint8_t(&val->subminor);
11242     size += vn_sizeof_uint8_t(&val->patch);
11243     return size;
11244 }
11245 
11246 static inline void
vn_decode_VkConformanceVersion(struct vn_cs_decoder * dec,VkConformanceVersion * val)11247 vn_decode_VkConformanceVersion(struct vn_cs_decoder *dec, VkConformanceVersion *val)
11248 {
11249     vn_decode_uint8_t(dec, &val->major);
11250     vn_decode_uint8_t(dec, &val->minor);
11251     vn_decode_uint8_t(dec, &val->subminor);
11252     vn_decode_uint8_t(dec, &val->patch);
11253 }
11254 
11255 static inline size_t
vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion * val)11256 vn_sizeof_VkConformanceVersion_partial(const VkConformanceVersion *val)
11257 {
11258     size_t size = 0;
11259     /* skip val->major */
11260     /* skip val->minor */
11261     /* skip val->subminor */
11262     /* skip val->patch */
11263     return size;
11264 }
11265 
11266 static inline void
vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder * enc,const VkConformanceVersion * val)11267 vn_encode_VkConformanceVersion_partial(struct vn_cs_encoder *enc, const VkConformanceVersion *val)
11268 {
11269     /* skip val->major */
11270     /* skip val->minor */
11271     /* skip val->subminor */
11272     /* skip val->patch */
11273 }
11274 
11275 /* struct VkPhysicalDeviceDriverProperties chain */
11276 
11277 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void * val)11278 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(const void *val)
11279 {
11280     /* no known/supported struct */
11281     return vn_sizeof_simple_pointer(NULL);
11282 }
11283 
11284 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties * val)11285 vn_sizeof_VkPhysicalDeviceDriverProperties_self(const VkPhysicalDeviceDriverProperties *val)
11286 {
11287     size_t size = 0;
11288     /* skip val->{sType,pNext} */
11289     size += vn_sizeof_VkDriverId(&val->driverID);
11290     size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
11291     size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
11292     size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
11293     size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
11294     size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
11295     return size;
11296 }
11297 
11298 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties * val)11299 vn_sizeof_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties *val)
11300 {
11301     size_t size = 0;
11302 
11303     size += vn_sizeof_VkStructureType(&val->sType);
11304     size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext(val->pNext);
11305     size += vn_sizeof_VkPhysicalDeviceDriverProperties_self(val);
11306 
11307     return size;
11308 }
11309 
11310 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder * dec,const void * val)11311 vn_decode_VkPhysicalDeviceDriverProperties_pnext(struct vn_cs_decoder *dec, const void *val)
11312 {
11313     /* no known/supported struct */
11314     if (vn_decode_simple_pointer(dec))
11315         assert(false);
11316 }
11317 
11318 static inline void
vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)11319 vn_decode_VkPhysicalDeviceDriverProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
11320 {
11321     /* skip val->{sType,pNext} */
11322     vn_decode_VkDriverId(dec, &val->driverID);
11323     {
11324         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
11325         vn_decode_char_array(dec, val->driverName, array_size);
11326     }
11327     {
11328         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
11329         vn_decode_char_array(dec, val->driverInfo, array_size);
11330     }
11331     vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
11332 }
11333 
11334 static inline void
vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDriverProperties * val)11335 vn_decode_VkPhysicalDeviceDriverProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDriverProperties *val)
11336 {
11337     VkStructureType stype;
11338     vn_decode_VkStructureType(dec, &stype);
11339     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
11340 
11341     assert(val->sType == stype);
11342     vn_decode_VkPhysicalDeviceDriverProperties_pnext(dec, val->pNext);
11343     vn_decode_VkPhysicalDeviceDriverProperties_self(dec, val);
11344 }
11345 
11346 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void * val)11347 vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(const void *val)
11348 {
11349     /* no known/supported struct */
11350     return vn_sizeof_simple_pointer(NULL);
11351 }
11352 
11353 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties * val)11354 vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(const VkPhysicalDeviceDriverProperties *val)
11355 {
11356     size_t size = 0;
11357     /* skip val->{sType,pNext} */
11358     /* skip val->driverID */
11359     /* skip val->driverName */
11360     /* skip val->driverInfo */
11361     size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
11362     return size;
11363 }
11364 
11365 static inline size_t
vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties * val)11366 vn_sizeof_VkPhysicalDeviceDriverProperties_partial(const VkPhysicalDeviceDriverProperties *val)
11367 {
11368     size_t size = 0;
11369 
11370     size += vn_sizeof_VkStructureType(&val->sType);
11371     size += vn_sizeof_VkPhysicalDeviceDriverProperties_pnext_partial(val->pNext);
11372     size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial(val);
11373 
11374     return size;
11375 }
11376 
11377 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)11378 vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
11379 {
11380     /* no known/supported struct */
11381     vn_encode_simple_pointer(enc, NULL);
11382 }
11383 
11384 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)11385 vn_encode_VkPhysicalDeviceDriverProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
11386 {
11387     /* skip val->{sType,pNext} */
11388     /* skip val->driverID */
11389     /* skip val->driverName */
11390     /* skip val->driverInfo */
11391     vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
11392 }
11393 
11394 static inline void
vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDriverProperties * val)11395 vn_encode_VkPhysicalDeviceDriverProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDriverProperties *val)
11396 {
11397     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
11398     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES });
11399     vn_encode_VkPhysicalDeviceDriverProperties_pnext_partial(enc, val->pNext);
11400     vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, val);
11401 }
11402 
11403 /* struct VkPhysicalDeviceIDProperties chain */
11404 
11405 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void * val)11406 vn_sizeof_VkPhysicalDeviceIDProperties_pnext(const void *val)
11407 {
11408     /* no known/supported struct */
11409     return vn_sizeof_simple_pointer(NULL);
11410 }
11411 
11412 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties * val)11413 vn_sizeof_VkPhysicalDeviceIDProperties_self(const VkPhysicalDeviceIDProperties *val)
11414 {
11415     size_t size = 0;
11416     /* skip val->{sType,pNext} */
11417     size += vn_sizeof_array_size(VK_UUID_SIZE);
11418     size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
11419     size += vn_sizeof_array_size(VK_UUID_SIZE);
11420     size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
11421     size += vn_sizeof_array_size(VK_LUID_SIZE);
11422     size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
11423     size += vn_sizeof_uint32_t(&val->deviceNodeMask);
11424     size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
11425     return size;
11426 }
11427 
11428 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties * val)11429 vn_sizeof_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties *val)
11430 {
11431     size_t size = 0;
11432 
11433     size += vn_sizeof_VkStructureType(&val->sType);
11434     size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext(val->pNext);
11435     size += vn_sizeof_VkPhysicalDeviceIDProperties_self(val);
11436 
11437     return size;
11438 }
11439 
11440 static inline void
vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder * dec,const void * val)11441 vn_decode_VkPhysicalDeviceIDProperties_pnext(struct vn_cs_decoder *dec, const void *val)
11442 {
11443     /* no known/supported struct */
11444     if (vn_decode_simple_pointer(dec))
11445         assert(false);
11446 }
11447 
11448 static inline void
vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)11449 vn_decode_VkPhysicalDeviceIDProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
11450 {
11451     /* skip val->{sType,pNext} */
11452     {
11453         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
11454         vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
11455     }
11456     {
11457         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
11458         vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
11459     }
11460     {
11461         const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
11462         vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
11463     }
11464     vn_decode_uint32_t(dec, &val->deviceNodeMask);
11465     vn_decode_VkBool32(dec, &val->deviceLUIDValid);
11466 }
11467 
11468 static inline void
vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceIDProperties * val)11469 vn_decode_VkPhysicalDeviceIDProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceIDProperties *val)
11470 {
11471     VkStructureType stype;
11472     vn_decode_VkStructureType(dec, &stype);
11473     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
11474 
11475     assert(val->sType == stype);
11476     vn_decode_VkPhysicalDeviceIDProperties_pnext(dec, val->pNext);
11477     vn_decode_VkPhysicalDeviceIDProperties_self(dec, val);
11478 }
11479 
11480 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void * val)11481 vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(const void *val)
11482 {
11483     /* no known/supported struct */
11484     return vn_sizeof_simple_pointer(NULL);
11485 }
11486 
11487 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties * val)11488 vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(const VkPhysicalDeviceIDProperties *val)
11489 {
11490     size_t size = 0;
11491     /* skip val->{sType,pNext} */
11492     /* skip val->deviceUUID */
11493     /* skip val->driverUUID */
11494     /* skip val->deviceLUID */
11495     /* skip val->deviceNodeMask */
11496     /* skip val->deviceLUIDValid */
11497     return size;
11498 }
11499 
11500 static inline size_t
vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties * val)11501 vn_sizeof_VkPhysicalDeviceIDProperties_partial(const VkPhysicalDeviceIDProperties *val)
11502 {
11503     size_t size = 0;
11504 
11505     size += vn_sizeof_VkStructureType(&val->sType);
11506     size += vn_sizeof_VkPhysicalDeviceIDProperties_pnext_partial(val->pNext);
11507     size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial(val);
11508 
11509     return size;
11510 }
11511 
11512 static inline void
vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)11513 vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
11514 {
11515     /* no known/supported struct */
11516     vn_encode_simple_pointer(enc, NULL);
11517 }
11518 
11519 static inline void
vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)11520 vn_encode_VkPhysicalDeviceIDProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
11521 {
11522     /* skip val->{sType,pNext} */
11523     /* skip val->deviceUUID */
11524     /* skip val->driverUUID */
11525     /* skip val->deviceLUID */
11526     /* skip val->deviceNodeMask */
11527     /* skip val->deviceLUIDValid */
11528 }
11529 
11530 static inline void
vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceIDProperties * val)11531 vn_encode_VkPhysicalDeviceIDProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceIDProperties *val)
11532 {
11533     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
11534     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES });
11535     vn_encode_VkPhysicalDeviceIDProperties_pnext_partial(enc, val->pNext);
11536     vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, val);
11537 }
11538 
11539 /* struct VkPhysicalDeviceMultiviewProperties chain */
11540 
11541 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void * val)11542 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(const void *val)
11543 {
11544     /* no known/supported struct */
11545     return vn_sizeof_simple_pointer(NULL);
11546 }
11547 
11548 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties * val)11549 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(const VkPhysicalDeviceMultiviewProperties *val)
11550 {
11551     size_t size = 0;
11552     /* skip val->{sType,pNext} */
11553     size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
11554     size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
11555     return size;
11556 }
11557 
11558 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties * val)11559 vn_sizeof_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties *val)
11560 {
11561     size_t size = 0;
11562 
11563     size += vn_sizeof_VkStructureType(&val->sType);
11564     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext(val->pNext);
11565     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self(val);
11566 
11567     return size;
11568 }
11569 
11570 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder * dec,const void * val)11571 vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(struct vn_cs_decoder *dec, const void *val)
11572 {
11573     /* no known/supported struct */
11574     if (vn_decode_simple_pointer(dec))
11575         assert(false);
11576 }
11577 
11578 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)11579 vn_decode_VkPhysicalDeviceMultiviewProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
11580 {
11581     /* skip val->{sType,pNext} */
11582     vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
11583     vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
11584 }
11585 
11586 static inline void
vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceMultiviewProperties * val)11587 vn_decode_VkPhysicalDeviceMultiviewProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceMultiviewProperties *val)
11588 {
11589     VkStructureType stype;
11590     vn_decode_VkStructureType(dec, &stype);
11591     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
11592 
11593     assert(val->sType == stype);
11594     vn_decode_VkPhysicalDeviceMultiviewProperties_pnext(dec, val->pNext);
11595     vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, val);
11596 }
11597 
11598 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void * val)11599 vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(const void *val)
11600 {
11601     /* no known/supported struct */
11602     return vn_sizeof_simple_pointer(NULL);
11603 }
11604 
11605 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties * val)11606 vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(const VkPhysicalDeviceMultiviewProperties *val)
11607 {
11608     size_t size = 0;
11609     /* skip val->{sType,pNext} */
11610     /* skip val->maxMultiviewViewCount */
11611     /* skip val->maxMultiviewInstanceIndex */
11612     return size;
11613 }
11614 
11615 static inline size_t
vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties * val)11616 vn_sizeof_VkPhysicalDeviceMultiviewProperties_partial(const VkPhysicalDeviceMultiviewProperties *val)
11617 {
11618     size_t size = 0;
11619 
11620     size += vn_sizeof_VkStructureType(&val->sType);
11621     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_pnext_partial(val->pNext);
11622     size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial(val);
11623 
11624     return size;
11625 }
11626 
11627 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)11628 vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
11629 {
11630     /* no known/supported struct */
11631     vn_encode_simple_pointer(enc, NULL);
11632 }
11633 
11634 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)11635 vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
11636 {
11637     /* skip val->{sType,pNext} */
11638     /* skip val->maxMultiviewViewCount */
11639     /* skip val->maxMultiviewInstanceIndex */
11640 }
11641 
11642 static inline void
vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMultiviewProperties * val)11643 vn_encode_VkPhysicalDeviceMultiviewProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMultiviewProperties *val)
11644 {
11645     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
11646     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES });
11647     vn_encode_VkPhysicalDeviceMultiviewProperties_pnext_partial(enc, val->pNext);
11648     vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, val);
11649 }
11650 
11651 /* struct VkPhysicalDeviceSubgroupProperties chain */
11652 
11653 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void * val)11654 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(const void *val)
11655 {
11656     /* no known/supported struct */
11657     return vn_sizeof_simple_pointer(NULL);
11658 }
11659 
11660 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties * val)11661 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(const VkPhysicalDeviceSubgroupProperties *val)
11662 {
11663     size_t size = 0;
11664     /* skip val->{sType,pNext} */
11665     size += vn_sizeof_uint32_t(&val->subgroupSize);
11666     size += vn_sizeof_VkFlags(&val->supportedStages);
11667     size += vn_sizeof_VkFlags(&val->supportedOperations);
11668     size += vn_sizeof_VkBool32(&val->quadOperationsInAllStages);
11669     return size;
11670 }
11671 
11672 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties * val)11673 vn_sizeof_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties *val)
11674 {
11675     size_t size = 0;
11676 
11677     size += vn_sizeof_VkStructureType(&val->sType);
11678     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext(val->pNext);
11679     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self(val);
11680 
11681     return size;
11682 }
11683 
11684 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)11685 vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
11686 {
11687     /* no known/supported struct */
11688     if (vn_decode_simple_pointer(dec))
11689         assert(false);
11690 }
11691 
11692 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)11693 vn_decode_VkPhysicalDeviceSubgroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
11694 {
11695     /* skip val->{sType,pNext} */
11696     vn_decode_uint32_t(dec, &val->subgroupSize);
11697     vn_decode_VkFlags(dec, &val->supportedStages);
11698     vn_decode_VkFlags(dec, &val->supportedOperations);
11699     vn_decode_VkBool32(dec, &val->quadOperationsInAllStages);
11700 }
11701 
11702 static inline void
vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupProperties * val)11703 vn_decode_VkPhysicalDeviceSubgroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupProperties *val)
11704 {
11705     VkStructureType stype;
11706     vn_decode_VkStructureType(dec, &stype);
11707     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
11708 
11709     assert(val->sType == stype);
11710     vn_decode_VkPhysicalDeviceSubgroupProperties_pnext(dec, val->pNext);
11711     vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, val);
11712 }
11713 
11714 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void * val)11715 vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(const void *val)
11716 {
11717     /* no known/supported struct */
11718     return vn_sizeof_simple_pointer(NULL);
11719 }
11720 
11721 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties * val)11722 vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(const VkPhysicalDeviceSubgroupProperties *val)
11723 {
11724     size_t size = 0;
11725     /* skip val->{sType,pNext} */
11726     /* skip val->subgroupSize */
11727     /* skip val->supportedStages */
11728     /* skip val->supportedOperations */
11729     /* skip val->quadOperationsInAllStages */
11730     return size;
11731 }
11732 
11733 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties * val)11734 vn_sizeof_VkPhysicalDeviceSubgroupProperties_partial(const VkPhysicalDeviceSubgroupProperties *val)
11735 {
11736     size_t size = 0;
11737 
11738     size += vn_sizeof_VkStructureType(&val->sType);
11739     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_pnext_partial(val->pNext);
11740     size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial(val);
11741 
11742     return size;
11743 }
11744 
11745 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)11746 vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
11747 {
11748     /* no known/supported struct */
11749     vn_encode_simple_pointer(enc, NULL);
11750 }
11751 
11752 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)11753 vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
11754 {
11755     /* skip val->{sType,pNext} */
11756     /* skip val->subgroupSize */
11757     /* skip val->supportedStages */
11758     /* skip val->supportedOperations */
11759     /* skip val->quadOperationsInAllStages */
11760 }
11761 
11762 static inline void
vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupProperties * val)11763 vn_encode_VkPhysicalDeviceSubgroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupProperties *val)
11764 {
11765     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
11766     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES });
11767     vn_encode_VkPhysicalDeviceSubgroupProperties_pnext_partial(enc, val->pNext);
11768     vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, val);
11769 }
11770 
11771 /* struct VkPhysicalDevicePointClippingProperties chain */
11772 
11773 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void * val)11774 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(const void *val)
11775 {
11776     /* no known/supported struct */
11777     return vn_sizeof_simple_pointer(NULL);
11778 }
11779 
11780 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties * val)11781 vn_sizeof_VkPhysicalDevicePointClippingProperties_self(const VkPhysicalDevicePointClippingProperties *val)
11782 {
11783     size_t size = 0;
11784     /* skip val->{sType,pNext} */
11785     size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
11786     return size;
11787 }
11788 
11789 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties * val)11790 vn_sizeof_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties *val)
11791 {
11792     size_t size = 0;
11793 
11794     size += vn_sizeof_VkStructureType(&val->sType);
11795     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext(val->pNext);
11796     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self(val);
11797 
11798     return size;
11799 }
11800 
11801 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder * dec,const void * val)11802 vn_decode_VkPhysicalDevicePointClippingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
11803 {
11804     /* no known/supported struct */
11805     if (vn_decode_simple_pointer(dec))
11806         assert(false);
11807 }
11808 
11809 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)11810 vn_decode_VkPhysicalDevicePointClippingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
11811 {
11812     /* skip val->{sType,pNext} */
11813     vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
11814 }
11815 
11816 static inline void
vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder * dec,VkPhysicalDevicePointClippingProperties * val)11817 vn_decode_VkPhysicalDevicePointClippingProperties(struct vn_cs_decoder *dec, VkPhysicalDevicePointClippingProperties *val)
11818 {
11819     VkStructureType stype;
11820     vn_decode_VkStructureType(dec, &stype);
11821     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
11822 
11823     assert(val->sType == stype);
11824     vn_decode_VkPhysicalDevicePointClippingProperties_pnext(dec, val->pNext);
11825     vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, val);
11826 }
11827 
11828 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void * val)11829 vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(const void *val)
11830 {
11831     /* no known/supported struct */
11832     return vn_sizeof_simple_pointer(NULL);
11833 }
11834 
11835 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties * val)11836 vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(const VkPhysicalDevicePointClippingProperties *val)
11837 {
11838     size_t size = 0;
11839     /* skip val->{sType,pNext} */
11840     /* skip val->pointClippingBehavior */
11841     return size;
11842 }
11843 
11844 static inline size_t
vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties * val)11845 vn_sizeof_VkPhysicalDevicePointClippingProperties_partial(const VkPhysicalDevicePointClippingProperties *val)
11846 {
11847     size_t size = 0;
11848 
11849     size += vn_sizeof_VkStructureType(&val->sType);
11850     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_pnext_partial(val->pNext);
11851     size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial(val);
11852 
11853     return size;
11854 }
11855 
11856 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)11857 vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
11858 {
11859     /* no known/supported struct */
11860     vn_encode_simple_pointer(enc, NULL);
11861 }
11862 
11863 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)11864 vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
11865 {
11866     /* skip val->{sType,pNext} */
11867     /* skip val->pointClippingBehavior */
11868 }
11869 
11870 static inline void
vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDevicePointClippingProperties * val)11871 vn_encode_VkPhysicalDevicePointClippingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDevicePointClippingProperties *val)
11872 {
11873     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
11874     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES });
11875     vn_encode_VkPhysicalDevicePointClippingProperties_pnext_partial(enc, val->pNext);
11876     vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, val);
11877 }
11878 
11879 /* struct VkPhysicalDeviceProtectedMemoryProperties chain */
11880 
11881 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void * val)11882 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(const void *val)
11883 {
11884     /* no known/supported struct */
11885     return vn_sizeof_simple_pointer(NULL);
11886 }
11887 
11888 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties * val)11889 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(const VkPhysicalDeviceProtectedMemoryProperties *val)
11890 {
11891     size_t size = 0;
11892     /* skip val->{sType,pNext} */
11893     size += vn_sizeof_VkBool32(&val->protectedNoFault);
11894     return size;
11895 }
11896 
11897 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties * val)11898 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties *val)
11899 {
11900     size_t size = 0;
11901 
11902     size += vn_sizeof_VkStructureType(&val->sType);
11903     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext(val->pNext);
11904     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self(val);
11905 
11906     return size;
11907 }
11908 
11909 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder * dec,const void * val)11910 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(struct vn_cs_decoder *dec, const void *val)
11911 {
11912     /* no known/supported struct */
11913     if (vn_decode_simple_pointer(dec))
11914         assert(false);
11915 }
11916 
11917 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)11918 vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
11919 {
11920     /* skip val->{sType,pNext} */
11921     vn_decode_VkBool32(dec, &val->protectedNoFault);
11922 }
11923 
11924 static inline void
vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceProtectedMemoryProperties * val)11925 vn_decode_VkPhysicalDeviceProtectedMemoryProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceProtectedMemoryProperties *val)
11926 {
11927     VkStructureType stype;
11928     vn_decode_VkStructureType(dec, &stype);
11929     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
11930 
11931     assert(val->sType == stype);
11932     vn_decode_VkPhysicalDeviceProtectedMemoryProperties_pnext(dec, val->pNext);
11933     vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, val);
11934 }
11935 
11936 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void * val)11937 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(const void *val)
11938 {
11939     /* no known/supported struct */
11940     return vn_sizeof_simple_pointer(NULL);
11941 }
11942 
11943 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)11944 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
11945 {
11946     size_t size = 0;
11947     /* skip val->{sType,pNext} */
11948     /* skip val->protectedNoFault */
11949     return size;
11950 }
11951 
11952 static inline size_t
vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties * val)11953 vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_partial(const VkPhysicalDeviceProtectedMemoryProperties *val)
11954 {
11955     size_t size = 0;
11956 
11957     size += vn_sizeof_VkStructureType(&val->sType);
11958     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(val->pNext);
11959     size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial(val);
11960 
11961     return size;
11962 }
11963 
11964 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)11965 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
11966 {
11967     /* no known/supported struct */
11968     vn_encode_simple_pointer(enc, NULL);
11969 }
11970 
11971 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)11972 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
11973 {
11974     /* skip val->{sType,pNext} */
11975     /* skip val->protectedNoFault */
11976 }
11977 
11978 static inline void
vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProtectedMemoryProperties * val)11979 vn_encode_VkPhysicalDeviceProtectedMemoryProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProtectedMemoryProperties *val)
11980 {
11981     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
11982     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES });
11983     vn_encode_VkPhysicalDeviceProtectedMemoryProperties_pnext_partial(enc, val->pNext);
11984     vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, val);
11985 }
11986 
11987 /* struct VkPhysicalDeviceSamplerFilterMinmaxProperties chain */
11988 
11989 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void * val)11990 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(const void *val)
11991 {
11992     /* no known/supported struct */
11993     return vn_sizeof_simple_pointer(NULL);
11994 }
11995 
11996 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)11997 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
11998 {
11999     size_t size = 0;
12000     /* skip val->{sType,pNext} */
12001     size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
12002     size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
12003     return size;
12004 }
12005 
12006 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)12007 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
12008 {
12009     size_t size = 0;
12010 
12011     size += vn_sizeof_VkStructureType(&val->sType);
12012     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(val->pNext);
12013     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(val);
12014 
12015     return size;
12016 }
12017 
12018 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder * dec,const void * val)12019 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(struct vn_cs_decoder *dec, const void *val)
12020 {
12021     /* no known/supported struct */
12022     if (vn_decode_simple_pointer(dec))
12023         assert(false);
12024 }
12025 
12026 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)12027 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
12028 {
12029     /* skip val->{sType,pNext} */
12030     vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
12031     vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
12032 }
12033 
12034 static inline void
vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSamplerFilterMinmaxProperties * val)12035 vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
12036 {
12037     VkStructureType stype;
12038     vn_decode_VkStructureType(dec, &stype);
12039     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
12040 
12041     assert(val->sType == stype);
12042     vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext(dec, val->pNext);
12043     vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, val);
12044 }
12045 
12046 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void * val)12047 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(const void *val)
12048 {
12049     /* no known/supported struct */
12050     return vn_sizeof_simple_pointer(NULL);
12051 }
12052 
12053 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)12054 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
12055 {
12056     size_t size = 0;
12057     /* skip val->{sType,pNext} */
12058     /* skip val->filterMinmaxSingleComponentFormats */
12059     /* skip val->filterMinmaxImageComponentMapping */
12060     return size;
12061 }
12062 
12063 static inline size_t
vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)12064 vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
12065 {
12066     size_t size = 0;
12067 
12068     size += vn_sizeof_VkStructureType(&val->sType);
12069     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(val->pNext);
12070     size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(val);
12071 
12072     return size;
12073 }
12074 
12075 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)12076 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
12077 {
12078     /* no known/supported struct */
12079     vn_encode_simple_pointer(enc, NULL);
12080 }
12081 
12082 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)12083 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
12084 {
12085     /* skip val->{sType,pNext} */
12086     /* skip val->filterMinmaxSingleComponentFormats */
12087     /* skip val->filterMinmaxImageComponentMapping */
12088 }
12089 
12090 static inline void
vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSamplerFilterMinmaxProperties * val)12091 vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSamplerFilterMinmaxProperties *val)
12092 {
12093     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
12094     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES });
12095     vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_pnext_partial(enc, val->pNext);
12096     vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, val);
12097 }
12098 
12099 /* struct VkPhysicalDeviceInlineUniformBlockProperties chain */
12100 
12101 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(const void * val)12102 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(const void *val)
12103 {
12104     /* no known/supported struct */
12105     return vn_sizeof_simple_pointer(NULL);
12106 }
12107 
12108 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(const VkPhysicalDeviceInlineUniformBlockProperties * val)12109 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(const VkPhysicalDeviceInlineUniformBlockProperties *val)
12110 {
12111     size_t size = 0;
12112     /* skip val->{sType,pNext} */
12113     size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockSize);
12114     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInlineUniformBlocks);
12115     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
12116     size += vn_sizeof_uint32_t(&val->maxDescriptorSetInlineUniformBlocks);
12117     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
12118     return size;
12119 }
12120 
12121 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties * val)12122 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties *val)
12123 {
12124     size_t size = 0;
12125 
12126     size += vn_sizeof_VkStructureType(&val->sType);
12127     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext(val->pNext);
12128     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self(val);
12129 
12130     return size;
12131 }
12132 
12133 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(struct vn_cs_decoder * dec,const void * val)12134 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(struct vn_cs_decoder *dec, const void *val)
12135 {
12136     /* no known/supported struct */
12137     if (vn_decode_simple_pointer(dec))
12138         assert(false);
12139 }
12140 
12141 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockProperties * val)12142 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockProperties *val)
12143 {
12144     /* skip val->{sType,pNext} */
12145     vn_decode_uint32_t(dec, &val->maxInlineUniformBlockSize);
12146     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInlineUniformBlocks);
12147     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
12148     vn_decode_uint32_t(dec, &val->maxDescriptorSetInlineUniformBlocks);
12149     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
12150 }
12151 
12152 static inline void
vn_decode_VkPhysicalDeviceInlineUniformBlockProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceInlineUniformBlockProperties * val)12153 vn_decode_VkPhysicalDeviceInlineUniformBlockProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceInlineUniformBlockProperties *val)
12154 {
12155     VkStructureType stype;
12156     vn_decode_VkStructureType(dec, &stype);
12157     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
12158 
12159     assert(val->sType == stype);
12160     vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_pnext(dec, val->pNext);
12161     vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(dec, val);
12162 }
12163 
12164 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(const void * val)12165 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(const void *val)
12166 {
12167     /* no known/supported struct */
12168     return vn_sizeof_simple_pointer(NULL);
12169 }
12170 
12171 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(const VkPhysicalDeviceInlineUniformBlockProperties * val)12172 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(const VkPhysicalDeviceInlineUniformBlockProperties *val)
12173 {
12174     size_t size = 0;
12175     /* skip val->{sType,pNext} */
12176     /* skip val->maxInlineUniformBlockSize */
12177     /* skip val->maxPerStageDescriptorInlineUniformBlocks */
12178     /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
12179     /* skip val->maxDescriptorSetInlineUniformBlocks */
12180     /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
12181     return size;
12182 }
12183 
12184 static inline size_t
vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_partial(const VkPhysicalDeviceInlineUniformBlockProperties * val)12185 vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_partial(const VkPhysicalDeviceInlineUniformBlockProperties *val)
12186 {
12187     size_t size = 0;
12188 
12189     size += vn_sizeof_VkStructureType(&val->sType);
12190     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(val->pNext);
12191     size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(val);
12192 
12193     return size;
12194 }
12195 
12196 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)12197 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
12198 {
12199     /* no known/supported struct */
12200     vn_encode_simple_pointer(enc, NULL);
12201 }
12202 
12203 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockProperties * val)12204 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockProperties *val)
12205 {
12206     /* skip val->{sType,pNext} */
12207     /* skip val->maxInlineUniformBlockSize */
12208     /* skip val->maxPerStageDescriptorInlineUniformBlocks */
12209     /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
12210     /* skip val->maxDescriptorSetInlineUniformBlocks */
12211     /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
12212 }
12213 
12214 static inline void
vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceInlineUniformBlockProperties * val)12215 vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceInlineUniformBlockProperties *val)
12216 {
12217     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
12218     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES });
12219     vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_pnext_partial(enc, val->pNext);
12220     vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(enc, val);
12221 }
12222 
12223 /* struct VkPhysicalDeviceMaintenance3Properties chain */
12224 
12225 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void * val)12226 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(const void *val)
12227 {
12228     /* no known/supported struct */
12229     return vn_sizeof_simple_pointer(NULL);
12230 }
12231 
12232 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties * val)12233 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(const VkPhysicalDeviceMaintenance3Properties *val)
12234 {
12235     size_t size = 0;
12236     /* skip val->{sType,pNext} */
12237     size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
12238     size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
12239     return size;
12240 }
12241 
12242 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties * val)12243 vn_sizeof_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties *val)
12244 {
12245     size_t size = 0;
12246 
12247     size += vn_sizeof_VkStructureType(&val->sType);
12248     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext(val->pNext);
12249     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self(val);
12250 
12251     return size;
12252 }
12253 
12254 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder * dec,const void * val)12255 vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(struct vn_cs_decoder *dec, const void *val)
12256 {
12257     /* no known/supported struct */
12258     if (vn_decode_simple_pointer(dec))
12259         assert(false);
12260 }
12261 
12262 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)12263 vn_decode_VkPhysicalDeviceMaintenance3Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
12264 {
12265     /* skip val->{sType,pNext} */
12266     vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
12267     vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
12268 }
12269 
12270 static inline void
vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance3Properties * val)12271 vn_decode_VkPhysicalDeviceMaintenance3Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance3Properties *val)
12272 {
12273     VkStructureType stype;
12274     vn_decode_VkStructureType(dec, &stype);
12275     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
12276 
12277     assert(val->sType == stype);
12278     vn_decode_VkPhysicalDeviceMaintenance3Properties_pnext(dec, val->pNext);
12279     vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, val);
12280 }
12281 
12282 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void * val)12283 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(const void *val)
12284 {
12285     /* no known/supported struct */
12286     return vn_sizeof_simple_pointer(NULL);
12287 }
12288 
12289 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties * val)12290 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(const VkPhysicalDeviceMaintenance3Properties *val)
12291 {
12292     size_t size = 0;
12293     /* skip val->{sType,pNext} */
12294     /* skip val->maxPerSetDescriptors */
12295     /* skip val->maxMemoryAllocationSize */
12296     return size;
12297 }
12298 
12299 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties * val)12300 vn_sizeof_VkPhysicalDeviceMaintenance3Properties_partial(const VkPhysicalDeviceMaintenance3Properties *val)
12301 {
12302     size_t size = 0;
12303 
12304     size += vn_sizeof_VkStructureType(&val->sType);
12305     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_pnext_partial(val->pNext);
12306     size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial(val);
12307 
12308     return size;
12309 }
12310 
12311 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)12312 vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
12313 {
12314     /* no known/supported struct */
12315     vn_encode_simple_pointer(enc, NULL);
12316 }
12317 
12318 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)12319 vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
12320 {
12321     /* skip val->{sType,pNext} */
12322     /* skip val->maxPerSetDescriptors */
12323     /* skip val->maxMemoryAllocationSize */
12324 }
12325 
12326 static inline void
vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance3Properties * val)12327 vn_encode_VkPhysicalDeviceMaintenance3Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance3Properties *val)
12328 {
12329     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
12330     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES });
12331     vn_encode_VkPhysicalDeviceMaintenance3Properties_pnext_partial(enc, val->pNext);
12332     vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, val);
12333 }
12334 
12335 /* struct VkPhysicalDeviceMaintenance4Properties chain */
12336 
12337 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(const void * val)12338 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(const void *val)
12339 {
12340     /* no known/supported struct */
12341     return vn_sizeof_simple_pointer(NULL);
12342 }
12343 
12344 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(const VkPhysicalDeviceMaintenance4Properties * val)12345 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(const VkPhysicalDeviceMaintenance4Properties *val)
12346 {
12347     size_t size = 0;
12348     /* skip val->{sType,pNext} */
12349     size += vn_sizeof_VkDeviceSize(&val->maxBufferSize);
12350     return size;
12351 }
12352 
12353 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties * val)12354 vn_sizeof_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties *val)
12355 {
12356     size_t size = 0;
12357 
12358     size += vn_sizeof_VkStructureType(&val->sType);
12359     size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext(val->pNext);
12360     size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self(val);
12361 
12362     return size;
12363 }
12364 
12365 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(struct vn_cs_decoder * dec,const void * val)12366 vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(struct vn_cs_decoder *dec, const void *val)
12367 {
12368     /* no known/supported struct */
12369     if (vn_decode_simple_pointer(dec))
12370         assert(false);
12371 }
12372 
12373 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Properties * val)12374 vn_decode_VkPhysicalDeviceMaintenance4Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Properties *val)
12375 {
12376     /* skip val->{sType,pNext} */
12377     vn_decode_VkDeviceSize(dec, &val->maxBufferSize);
12378 }
12379 
12380 static inline void
vn_decode_VkPhysicalDeviceMaintenance4Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceMaintenance4Properties * val)12381 vn_decode_VkPhysicalDeviceMaintenance4Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance4Properties *val)
12382 {
12383     VkStructureType stype;
12384     vn_decode_VkStructureType(dec, &stype);
12385     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
12386 
12387     assert(val->sType == stype);
12388     vn_decode_VkPhysicalDeviceMaintenance4Properties_pnext(dec, val->pNext);
12389     vn_decode_VkPhysicalDeviceMaintenance4Properties_self(dec, val);
12390 }
12391 
12392 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(const void * val)12393 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(const void *val)
12394 {
12395     /* no known/supported struct */
12396     return vn_sizeof_simple_pointer(NULL);
12397 }
12398 
12399 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(const VkPhysicalDeviceMaintenance4Properties * val)12400 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(const VkPhysicalDeviceMaintenance4Properties *val)
12401 {
12402     size_t size = 0;
12403     /* skip val->{sType,pNext} */
12404     /* skip val->maxBufferSize */
12405     return size;
12406 }
12407 
12408 static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance4Properties_partial(const VkPhysicalDeviceMaintenance4Properties * val)12409 vn_sizeof_VkPhysicalDeviceMaintenance4Properties_partial(const VkPhysicalDeviceMaintenance4Properties *val)
12410 {
12411     size_t size = 0;
12412 
12413     size += vn_sizeof_VkStructureType(&val->sType);
12414     size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_pnext_partial(val->pNext);
12415     size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial(val);
12416 
12417     return size;
12418 }
12419 
12420 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)12421 vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
12422 {
12423     /* no known/supported struct */
12424     vn_encode_simple_pointer(enc, NULL);
12425 }
12426 
12427 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Properties * val)12428 vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Properties *val)
12429 {
12430     /* skip val->{sType,pNext} */
12431     /* skip val->maxBufferSize */
12432 }
12433 
12434 static inline void
vn_encode_VkPhysicalDeviceMaintenance4Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMaintenance4Properties * val)12435 vn_encode_VkPhysicalDeviceMaintenance4Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance4Properties *val)
12436 {
12437     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
12438     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES });
12439     vn_encode_VkPhysicalDeviceMaintenance4Properties_pnext_partial(enc, val->pNext);
12440     vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, val);
12441 }
12442 
12443 /* struct VkPhysicalDeviceFloatControlsProperties chain */
12444 
12445 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void * val)12446 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(const void *val)
12447 {
12448     /* no known/supported struct */
12449     return vn_sizeof_simple_pointer(NULL);
12450 }
12451 
12452 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties * val)12453 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(const VkPhysicalDeviceFloatControlsProperties *val)
12454 {
12455     size_t size = 0;
12456     /* skip val->{sType,pNext} */
12457     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
12458     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
12459     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
12460     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
12461     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
12462     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
12463     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
12464     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
12465     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
12466     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
12467     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
12468     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
12469     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
12470     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
12471     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
12472     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
12473     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
12474     return size;
12475 }
12476 
12477 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties * val)12478 vn_sizeof_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties *val)
12479 {
12480     size_t size = 0;
12481 
12482     size += vn_sizeof_VkStructureType(&val->sType);
12483     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext(val->pNext);
12484     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self(val);
12485 
12486     return size;
12487 }
12488 
12489 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder * dec,const void * val)12490 vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(struct vn_cs_decoder *dec, const void *val)
12491 {
12492     /* no known/supported struct */
12493     if (vn_decode_simple_pointer(dec))
12494         assert(false);
12495 }
12496 
12497 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)12498 vn_decode_VkPhysicalDeviceFloatControlsProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
12499 {
12500     /* skip val->{sType,pNext} */
12501     vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
12502     vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
12503     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
12504     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
12505     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
12506     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
12507     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
12508     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
12509     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
12510     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
12511     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
12512     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
12513     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
12514     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
12515     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
12516     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
12517     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
12518 }
12519 
12520 static inline void
vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceFloatControlsProperties * val)12521 vn_decode_VkPhysicalDeviceFloatControlsProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceFloatControlsProperties *val)
12522 {
12523     VkStructureType stype;
12524     vn_decode_VkStructureType(dec, &stype);
12525     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
12526 
12527     assert(val->sType == stype);
12528     vn_decode_VkPhysicalDeviceFloatControlsProperties_pnext(dec, val->pNext);
12529     vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, val);
12530 }
12531 
12532 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void * val)12533 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(const void *val)
12534 {
12535     /* no known/supported struct */
12536     return vn_sizeof_simple_pointer(NULL);
12537 }
12538 
12539 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties * val)12540 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(const VkPhysicalDeviceFloatControlsProperties *val)
12541 {
12542     size_t size = 0;
12543     /* skip val->{sType,pNext} */
12544     /* skip val->denormBehaviorIndependence */
12545     /* skip val->roundingModeIndependence */
12546     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
12547     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
12548     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
12549     /* skip val->shaderDenormPreserveFloat16 */
12550     /* skip val->shaderDenormPreserveFloat32 */
12551     /* skip val->shaderDenormPreserveFloat64 */
12552     /* skip val->shaderDenormFlushToZeroFloat16 */
12553     /* skip val->shaderDenormFlushToZeroFloat32 */
12554     /* skip val->shaderDenormFlushToZeroFloat64 */
12555     /* skip val->shaderRoundingModeRTEFloat16 */
12556     /* skip val->shaderRoundingModeRTEFloat32 */
12557     /* skip val->shaderRoundingModeRTEFloat64 */
12558     /* skip val->shaderRoundingModeRTZFloat16 */
12559     /* skip val->shaderRoundingModeRTZFloat32 */
12560     /* skip val->shaderRoundingModeRTZFloat64 */
12561     return size;
12562 }
12563 
12564 static inline size_t
vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties * val)12565 vn_sizeof_VkPhysicalDeviceFloatControlsProperties_partial(const VkPhysicalDeviceFloatControlsProperties *val)
12566 {
12567     size_t size = 0;
12568 
12569     size += vn_sizeof_VkStructureType(&val->sType);
12570     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_pnext_partial(val->pNext);
12571     size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial(val);
12572 
12573     return size;
12574 }
12575 
12576 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)12577 vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
12578 {
12579     /* no known/supported struct */
12580     vn_encode_simple_pointer(enc, NULL);
12581 }
12582 
12583 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)12584 vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
12585 {
12586     /* skip val->{sType,pNext} */
12587     /* skip val->denormBehaviorIndependence */
12588     /* skip val->roundingModeIndependence */
12589     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
12590     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
12591     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
12592     /* skip val->shaderDenormPreserveFloat16 */
12593     /* skip val->shaderDenormPreserveFloat32 */
12594     /* skip val->shaderDenormPreserveFloat64 */
12595     /* skip val->shaderDenormFlushToZeroFloat16 */
12596     /* skip val->shaderDenormFlushToZeroFloat32 */
12597     /* skip val->shaderDenormFlushToZeroFloat64 */
12598     /* skip val->shaderRoundingModeRTEFloat16 */
12599     /* skip val->shaderRoundingModeRTEFloat32 */
12600     /* skip val->shaderRoundingModeRTEFloat64 */
12601     /* skip val->shaderRoundingModeRTZFloat16 */
12602     /* skip val->shaderRoundingModeRTZFloat32 */
12603     /* skip val->shaderRoundingModeRTZFloat64 */
12604 }
12605 
12606 static inline void
vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceFloatControlsProperties * val)12607 vn_encode_VkPhysicalDeviceFloatControlsProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceFloatControlsProperties *val)
12608 {
12609     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
12610     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES });
12611     vn_encode_VkPhysicalDeviceFloatControlsProperties_pnext_partial(enc, val->pNext);
12612     vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, val);
12613 }
12614 
12615 /* struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT chain */
12616 
12617 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(const void * val)12618 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(const void *val)
12619 {
12620     /* no known/supported struct */
12621     return vn_sizeof_simple_pointer(NULL);
12622 }
12623 
12624 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12625 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12626 {
12627     size_t size = 0;
12628     /* skip val->{sType,pNext} */
12629     size += vn_sizeof_float(&val->primitiveOverestimationSize);
12630     size += vn_sizeof_float(&val->maxExtraPrimitiveOverestimationSize);
12631     size += vn_sizeof_float(&val->extraPrimitiveOverestimationSizeGranularity);
12632     size += vn_sizeof_VkBool32(&val->primitiveUnderestimation);
12633     size += vn_sizeof_VkBool32(&val->conservativePointAndLineRasterization);
12634     size += vn_sizeof_VkBool32(&val->degenerateTrianglesRasterized);
12635     size += vn_sizeof_VkBool32(&val->degenerateLinesRasterized);
12636     size += vn_sizeof_VkBool32(&val->fullyCoveredFragmentShaderInputVariable);
12637     size += vn_sizeof_VkBool32(&val->conservativeRasterizationPostDepthCoverage);
12638     return size;
12639 }
12640 
12641 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12642 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12643 {
12644     size_t size = 0;
12645 
12646     size += vn_sizeof_VkStructureType(&val->sType);
12647     size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(val->pNext);
12648     size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(val);
12649 
12650     return size;
12651 }
12652 
12653 static inline void
vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)12654 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
12655 {
12656     /* no known/supported struct */
12657     if (vn_decode_simple_pointer(dec))
12658         assert(false);
12659 }
12660 
12661 static inline void
vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12662 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12663 {
12664     /* skip val->{sType,pNext} */
12665     vn_decode_float(dec, &val->primitiveOverestimationSize);
12666     vn_decode_float(dec, &val->maxExtraPrimitiveOverestimationSize);
12667     vn_decode_float(dec, &val->extraPrimitiveOverestimationSizeGranularity);
12668     vn_decode_VkBool32(dec, &val->primitiveUnderestimation);
12669     vn_decode_VkBool32(dec, &val->conservativePointAndLineRasterization);
12670     vn_decode_VkBool32(dec, &val->degenerateTrianglesRasterized);
12671     vn_decode_VkBool32(dec, &val->degenerateLinesRasterized);
12672     vn_decode_VkBool32(dec, &val->fullyCoveredFragmentShaderInputVariable);
12673     vn_decode_VkBool32(dec, &val->conservativeRasterizationPostDepthCoverage);
12674 }
12675 
12676 static inline void
vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12677 vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12678 {
12679     VkStructureType stype;
12680     vn_decode_VkStructureType(dec, &stype);
12681     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
12682 
12683     assert(val->sType == stype);
12684     vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext(dec, val->pNext);
12685     vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(dec, val);
12686 }
12687 
12688 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(const void * val)12689 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(const void *val)
12690 {
12691     /* no known/supported struct */
12692     return vn_sizeof_simple_pointer(NULL);
12693 }
12694 
12695 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12696 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12697 {
12698     size_t size = 0;
12699     /* skip val->{sType,pNext} */
12700     /* skip val->primitiveOverestimationSize */
12701     /* skip val->maxExtraPrimitiveOverestimationSize */
12702     /* skip val->extraPrimitiveOverestimationSizeGranularity */
12703     /* skip val->primitiveUnderestimation */
12704     /* skip val->conservativePointAndLineRasterization */
12705     /* skip val->degenerateTrianglesRasterized */
12706     /* skip val->degenerateLinesRasterized */
12707     /* skip val->fullyCoveredFragmentShaderInputVariable */
12708     /* skip val->conservativeRasterizationPostDepthCoverage */
12709     return size;
12710 }
12711 
12712 static inline size_t
vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12713 vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12714 {
12715     size_t size = 0;
12716 
12717     size += vn_sizeof_VkStructureType(&val->sType);
12718     size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(val->pNext);
12719     size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(val);
12720 
12721     return size;
12722 }
12723 
12724 static inline void
vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)12725 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
12726 {
12727     /* no known/supported struct */
12728     vn_encode_simple_pointer(enc, NULL);
12729 }
12730 
12731 static inline void
vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12732 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12733 {
12734     /* skip val->{sType,pNext} */
12735     /* skip val->primitiveOverestimationSize */
12736     /* skip val->maxExtraPrimitiveOverestimationSize */
12737     /* skip val->extraPrimitiveOverestimationSizeGranularity */
12738     /* skip val->primitiveUnderestimation */
12739     /* skip val->conservativePointAndLineRasterization */
12740     /* skip val->degenerateTrianglesRasterized */
12741     /* skip val->degenerateLinesRasterized */
12742     /* skip val->fullyCoveredFragmentShaderInputVariable */
12743     /* skip val->conservativeRasterizationPostDepthCoverage */
12744 }
12745 
12746 static inline void
vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceConservativeRasterizationPropertiesEXT * val)12747 vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *val)
12748 {
12749     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
12750     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT });
12751     vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_pnext_partial(enc, val->pNext);
12752     vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(enc, val);
12753 }
12754 
12755 /* struct VkPhysicalDeviceDescriptorIndexingProperties chain */
12756 
12757 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void * val)12758 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(const void *val)
12759 {
12760     /* no known/supported struct */
12761     return vn_sizeof_simple_pointer(NULL);
12762 }
12763 
12764 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties * val)12765 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(const VkPhysicalDeviceDescriptorIndexingProperties *val)
12766 {
12767     size_t size = 0;
12768     /* skip val->{sType,pNext} */
12769     size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
12770     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
12771     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
12772     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
12773     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
12774     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
12775     size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
12776     size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
12777     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
12778     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
12779     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
12780     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
12781     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
12782     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
12783     size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
12784     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
12785     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
12786     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
12787     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
12788     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
12789     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
12790     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
12791     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
12792     return size;
12793 }
12794 
12795 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties * val)12796 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties *val)
12797 {
12798     size_t size = 0;
12799 
12800     size += vn_sizeof_VkStructureType(&val->sType);
12801     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext(val->pNext);
12802     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self(val);
12803 
12804     return size;
12805 }
12806 
12807 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder * dec,const void * val)12808 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(struct vn_cs_decoder *dec, const void *val)
12809 {
12810     /* no known/supported struct */
12811     if (vn_decode_simple_pointer(dec))
12812         assert(false);
12813 }
12814 
12815 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)12816 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
12817 {
12818     /* skip val->{sType,pNext} */
12819     vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
12820     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
12821     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
12822     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
12823     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
12824     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
12825     vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
12826     vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
12827     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
12828     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
12829     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
12830     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
12831     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
12832     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
12833     vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
12834     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
12835     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
12836     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
12837     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
12838     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
12839     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
12840     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
12841     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
12842 }
12843 
12844 static inline void
vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDescriptorIndexingProperties * val)12845 vn_decode_VkPhysicalDeviceDescriptorIndexingProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDescriptorIndexingProperties *val)
12846 {
12847     VkStructureType stype;
12848     vn_decode_VkStructureType(dec, &stype);
12849     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
12850 
12851     assert(val->sType == stype);
12852     vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_pnext(dec, val->pNext);
12853     vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, val);
12854 }
12855 
12856 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void * val)12857 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(const void *val)
12858 {
12859     /* no known/supported struct */
12860     return vn_sizeof_simple_pointer(NULL);
12861 }
12862 
12863 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)12864 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
12865 {
12866     size_t size = 0;
12867     /* skip val->{sType,pNext} */
12868     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
12869     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
12870     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
12871     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
12872     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
12873     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
12874     /* skip val->robustBufferAccessUpdateAfterBind */
12875     /* skip val->quadDivergentImplicitLod */
12876     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
12877     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
12878     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
12879     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
12880     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
12881     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
12882     /* skip val->maxPerStageUpdateAfterBindResources */
12883     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
12884     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
12885     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
12886     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
12887     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
12888     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
12889     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
12890     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
12891     return size;
12892 }
12893 
12894 static inline size_t
vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties * val)12895 vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_partial(const VkPhysicalDeviceDescriptorIndexingProperties *val)
12896 {
12897     size_t size = 0;
12898 
12899     size += vn_sizeof_VkStructureType(&val->sType);
12900     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(val->pNext);
12901     size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(val);
12902 
12903     return size;
12904 }
12905 
12906 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)12907 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
12908 {
12909     /* no known/supported struct */
12910     vn_encode_simple_pointer(enc, NULL);
12911 }
12912 
12913 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)12914 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
12915 {
12916     /* skip val->{sType,pNext} */
12917     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
12918     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
12919     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
12920     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
12921     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
12922     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
12923     /* skip val->robustBufferAccessUpdateAfterBind */
12924     /* skip val->quadDivergentImplicitLod */
12925     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
12926     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
12927     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
12928     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
12929     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
12930     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
12931     /* skip val->maxPerStageUpdateAfterBindResources */
12932     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
12933     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
12934     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
12935     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
12936     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
12937     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
12938     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
12939     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
12940 }
12941 
12942 static inline void
vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDescriptorIndexingProperties * val)12943 vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDescriptorIndexingProperties *val)
12944 {
12945     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
12946     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES });
12947     vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_pnext_partial(enc, val->pNext);
12948     vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, val);
12949 }
12950 
12951 /* struct VkPhysicalDeviceTimelineSemaphoreProperties chain */
12952 
12953 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void * val)12954 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(const void *val)
12955 {
12956     /* no known/supported struct */
12957     return vn_sizeof_simple_pointer(NULL);
12958 }
12959 
12960 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties * val)12961 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
12962 {
12963     size_t size = 0;
12964     /* skip val->{sType,pNext} */
12965     size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
12966     return size;
12967 }
12968 
12969 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties * val)12970 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
12971 {
12972     size_t size = 0;
12973 
12974     size += vn_sizeof_VkStructureType(&val->sType);
12975     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(val->pNext);
12976     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self(val);
12977 
12978     return size;
12979 }
12980 
12981 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)12982 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
12983 {
12984     /* no known/supported struct */
12985     if (vn_decode_simple_pointer(dec))
12986         assert(false);
12987 }
12988 
12989 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)12990 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
12991 {
12992     /* skip val->{sType,pNext} */
12993     vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
12994 }
12995 
12996 static inline void
vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceTimelineSemaphoreProperties * val)12997 vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTimelineSemaphoreProperties *val)
12998 {
12999     VkStructureType stype;
13000     vn_decode_VkStructureType(dec, &stype);
13001     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
13002 
13003     assert(val->sType == stype);
13004     vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext(dec, val->pNext);
13005     vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, val);
13006 }
13007 
13008 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void * val)13009 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(const void *val)
13010 {
13011     /* no known/supported struct */
13012     return vn_sizeof_simple_pointer(NULL);
13013 }
13014 
13015 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)13016 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
13017 {
13018     size_t size = 0;
13019     /* skip val->{sType,pNext} */
13020     /* skip val->maxTimelineSemaphoreValueDifference */
13021     return size;
13022 }
13023 
13024 static inline size_t
vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties * val)13025 vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_partial(const VkPhysicalDeviceTimelineSemaphoreProperties *val)
13026 {
13027     size_t size = 0;
13028 
13029     size += vn_sizeof_VkStructureType(&val->sType);
13030     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(val->pNext);
13031     size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(val);
13032 
13033     return size;
13034 }
13035 
13036 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)13037 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13038 {
13039     /* no known/supported struct */
13040     vn_encode_simple_pointer(enc, NULL);
13041 }
13042 
13043 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)13044 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
13045 {
13046     /* skip val->{sType,pNext} */
13047     /* skip val->maxTimelineSemaphoreValueDifference */
13048 }
13049 
13050 static inline void
vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTimelineSemaphoreProperties * val)13051 vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTimelineSemaphoreProperties *val)
13052 {
13053     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
13054     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES });
13055     vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_pnext_partial(enc, val->pNext);
13056     vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, val);
13057 }
13058 
13059 /* struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT chain */
13060 
13061 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(const void * val)13062 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(const void *val)
13063 {
13064     /* no known/supported struct */
13065     return vn_sizeof_simple_pointer(NULL);
13066 }
13067 
13068 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13069 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13070 {
13071     size_t size = 0;
13072     /* skip val->{sType,pNext} */
13073     size += vn_sizeof_uint32_t(&val->maxVertexAttribDivisor);
13074     return size;
13075 }
13076 
13077 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13078 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13079 {
13080     size_t size = 0;
13081 
13082     size += vn_sizeof_VkStructureType(&val->sType);
13083     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(val->pNext);
13084     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(val);
13085 
13086     return size;
13087 }
13088 
13089 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)13090 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
13091 {
13092     /* no known/supported struct */
13093     if (vn_decode_simple_pointer(dec))
13094         assert(false);
13095 }
13096 
13097 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13098 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13099 {
13100     /* skip val->{sType,pNext} */
13101     vn_decode_uint32_t(dec, &val->maxVertexAttribDivisor);
13102 }
13103 
13104 static inline void
vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13105 vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13106 {
13107     VkStructureType stype;
13108     vn_decode_VkStructureType(dec, &stype);
13109     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
13110 
13111     assert(val->sType == stype);
13112     vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext(dec, val->pNext);
13113     vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(dec, val);
13114 }
13115 
13116 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(const void * val)13117 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(const void *val)
13118 {
13119     /* no known/supported struct */
13120     return vn_sizeof_simple_pointer(NULL);
13121 }
13122 
13123 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13124 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13125 {
13126     size_t size = 0;
13127     /* skip val->{sType,pNext} */
13128     /* skip val->maxVertexAttribDivisor */
13129     return size;
13130 }
13131 
13132 static inline size_t
vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13133 vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13134 {
13135     size_t size = 0;
13136 
13137     size += vn_sizeof_VkStructureType(&val->sType);
13138     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(val->pNext);
13139     size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(val);
13140 
13141     return size;
13142 }
13143 
13144 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)13145 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13146 {
13147     /* no known/supported struct */
13148     vn_encode_simple_pointer(enc, NULL);
13149 }
13150 
13151 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13152 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13153 {
13154     /* skip val->{sType,pNext} */
13155     /* skip val->maxVertexAttribDivisor */
13156 }
13157 
13158 static inline void
vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT * val)13159 vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *val)
13160 {
13161     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
13162     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT });
13163     vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_pnext_partial(enc, val->pNext);
13164     vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(enc, val);
13165 }
13166 
13167 /* struct VkPhysicalDeviceDepthStencilResolveProperties chain */
13168 
13169 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void * val)13170 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(const void *val)
13171 {
13172     /* no known/supported struct */
13173     return vn_sizeof_simple_pointer(NULL);
13174 }
13175 
13176 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties * val)13177 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(const VkPhysicalDeviceDepthStencilResolveProperties *val)
13178 {
13179     size_t size = 0;
13180     /* skip val->{sType,pNext} */
13181     size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
13182     size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
13183     size += vn_sizeof_VkBool32(&val->independentResolveNone);
13184     size += vn_sizeof_VkBool32(&val->independentResolve);
13185     return size;
13186 }
13187 
13188 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties * val)13189 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties *val)
13190 {
13191     size_t size = 0;
13192 
13193     size += vn_sizeof_VkStructureType(&val->sType);
13194     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext(val->pNext);
13195     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self(val);
13196 
13197     return size;
13198 }
13199 
13200 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder * dec,const void * val)13201 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(struct vn_cs_decoder *dec, const void *val)
13202 {
13203     /* no known/supported struct */
13204     if (vn_decode_simple_pointer(dec))
13205         assert(false);
13206 }
13207 
13208 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)13209 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
13210 {
13211     /* skip val->{sType,pNext} */
13212     vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
13213     vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
13214     vn_decode_VkBool32(dec, &val->independentResolveNone);
13215     vn_decode_VkBool32(dec, &val->independentResolve);
13216 }
13217 
13218 static inline void
vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceDepthStencilResolveProperties * val)13219 vn_decode_VkPhysicalDeviceDepthStencilResolveProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceDepthStencilResolveProperties *val)
13220 {
13221     VkStructureType stype;
13222     vn_decode_VkStructureType(dec, &stype);
13223     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
13224 
13225     assert(val->sType == stype);
13226     vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_pnext(dec, val->pNext);
13227     vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, val);
13228 }
13229 
13230 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void * val)13231 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(const void *val)
13232 {
13233     /* no known/supported struct */
13234     return vn_sizeof_simple_pointer(NULL);
13235 }
13236 
13237 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)13238 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
13239 {
13240     size_t size = 0;
13241     /* skip val->{sType,pNext} */
13242     /* skip val->supportedDepthResolveModes */
13243     /* skip val->supportedStencilResolveModes */
13244     /* skip val->independentResolveNone */
13245     /* skip val->independentResolve */
13246     return size;
13247 }
13248 
13249 static inline size_t
vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties * val)13250 vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_partial(const VkPhysicalDeviceDepthStencilResolveProperties *val)
13251 {
13252     size_t size = 0;
13253 
13254     size += vn_sizeof_VkStructureType(&val->sType);
13255     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(val->pNext);
13256     size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(val);
13257 
13258     return size;
13259 }
13260 
13261 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)13262 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13263 {
13264     /* no known/supported struct */
13265     vn_encode_simple_pointer(enc, NULL);
13266 }
13267 
13268 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)13269 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
13270 {
13271     /* skip val->{sType,pNext} */
13272     /* skip val->supportedDepthResolveModes */
13273     /* skip val->supportedStencilResolveModes */
13274     /* skip val->independentResolveNone */
13275     /* skip val->independentResolve */
13276 }
13277 
13278 static inline void
vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceDepthStencilResolveProperties * val)13279 vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceDepthStencilResolveProperties *val)
13280 {
13281     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
13282     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES });
13283     vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_pnext_partial(enc, val->pNext);
13284     vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, val);
13285 }
13286 
13287 /* struct VkPhysicalDeviceTransformFeedbackPropertiesEXT chain */
13288 
13289 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void * val)13290 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(const void *val)
13291 {
13292     /* no known/supported struct */
13293     return vn_sizeof_simple_pointer(NULL);
13294 }
13295 
13296 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13297 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13298 {
13299     size_t size = 0;
13300     /* skip val->{sType,pNext} */
13301     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreams);
13302     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBuffers);
13303     size += vn_sizeof_VkDeviceSize(&val->maxTransformFeedbackBufferSize);
13304     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackStreamDataSize);
13305     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataSize);
13306     size += vn_sizeof_uint32_t(&val->maxTransformFeedbackBufferDataStride);
13307     size += vn_sizeof_VkBool32(&val->transformFeedbackQueries);
13308     size += vn_sizeof_VkBool32(&val->transformFeedbackStreamsLinesTriangles);
13309     size += vn_sizeof_VkBool32(&val->transformFeedbackRasterizationStreamSelect);
13310     size += vn_sizeof_VkBool32(&val->transformFeedbackDraw);
13311     return size;
13312 }
13313 
13314 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13315 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13316 {
13317     size_t size = 0;
13318 
13319     size += vn_sizeof_VkStructureType(&val->sType);
13320     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(val->pNext);
13321     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(val);
13322 
13323     return size;
13324 }
13325 
13326 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)13327 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
13328 {
13329     /* no known/supported struct */
13330     if (vn_decode_simple_pointer(dec))
13331         assert(false);
13332 }
13333 
13334 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13335 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13336 {
13337     /* skip val->{sType,pNext} */
13338     vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreams);
13339     vn_decode_uint32_t(dec, &val->maxTransformFeedbackBuffers);
13340     vn_decode_VkDeviceSize(dec, &val->maxTransformFeedbackBufferSize);
13341     vn_decode_uint32_t(dec, &val->maxTransformFeedbackStreamDataSize);
13342     vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataSize);
13343     vn_decode_uint32_t(dec, &val->maxTransformFeedbackBufferDataStride);
13344     vn_decode_VkBool32(dec, &val->transformFeedbackQueries);
13345     vn_decode_VkBool32(dec, &val->transformFeedbackStreamsLinesTriangles);
13346     vn_decode_VkBool32(dec, &val->transformFeedbackRasterizationStreamSelect);
13347     vn_decode_VkBool32(dec, &val->transformFeedbackDraw);
13348 }
13349 
13350 static inline void
vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13351 vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13352 {
13353     VkStructureType stype;
13354     vn_decode_VkStructureType(dec, &stype);
13355     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
13356 
13357     assert(val->sType == stype);
13358     vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext(dec, val->pNext);
13359     vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, val);
13360 }
13361 
13362 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void * val)13363 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(const void *val)
13364 {
13365     /* no known/supported struct */
13366     return vn_sizeof_simple_pointer(NULL);
13367 }
13368 
13369 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13370 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13371 {
13372     size_t size = 0;
13373     /* skip val->{sType,pNext} */
13374     /* skip val->maxTransformFeedbackStreams */
13375     /* skip val->maxTransformFeedbackBuffers */
13376     /* skip val->maxTransformFeedbackBufferSize */
13377     /* skip val->maxTransformFeedbackStreamDataSize */
13378     /* skip val->maxTransformFeedbackBufferDataSize */
13379     /* skip val->maxTransformFeedbackBufferDataStride */
13380     /* skip val->transformFeedbackQueries */
13381     /* skip val->transformFeedbackStreamsLinesTriangles */
13382     /* skip val->transformFeedbackRasterizationStreamSelect */
13383     /* skip val->transformFeedbackDraw */
13384     return size;
13385 }
13386 
13387 static inline size_t
vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13388 vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13389 {
13390     size_t size = 0;
13391 
13392     size += vn_sizeof_VkStructureType(&val->sType);
13393     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(val->pNext);
13394     size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(val);
13395 
13396     return size;
13397 }
13398 
13399 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)13400 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13401 {
13402     /* no known/supported struct */
13403     vn_encode_simple_pointer(enc, NULL);
13404 }
13405 
13406 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13407 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13408 {
13409     /* skip val->{sType,pNext} */
13410     /* skip val->maxTransformFeedbackStreams */
13411     /* skip val->maxTransformFeedbackBuffers */
13412     /* skip val->maxTransformFeedbackBufferSize */
13413     /* skip val->maxTransformFeedbackStreamDataSize */
13414     /* skip val->maxTransformFeedbackBufferDataSize */
13415     /* skip val->maxTransformFeedbackBufferDataStride */
13416     /* skip val->transformFeedbackQueries */
13417     /* skip val->transformFeedbackStreamsLinesTriangles */
13418     /* skip val->transformFeedbackRasterizationStreamSelect */
13419     /* skip val->transformFeedbackDraw */
13420 }
13421 
13422 static inline void
vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTransformFeedbackPropertiesEXT * val)13423 vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *val)
13424 {
13425     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
13426     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT });
13427     vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_pnext_partial(enc, val->pNext);
13428     vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, val);
13429 }
13430 
13431 /* struct VkPhysicalDeviceTexelBufferAlignmentProperties chain */
13432 
13433 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(const void * val)13434 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(const void *val)
13435 {
13436     /* no known/supported struct */
13437     return vn_sizeof_simple_pointer(NULL);
13438 }
13439 
13440 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)13441 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13442 {
13443     size_t size = 0;
13444     /* skip val->{sType,pNext} */
13445     size += vn_sizeof_VkDeviceSize(&val->storageTexelBufferOffsetAlignmentBytes);
13446     size += vn_sizeof_VkBool32(&val->storageTexelBufferOffsetSingleTexelAlignment);
13447     size += vn_sizeof_VkDeviceSize(&val->uniformTexelBufferOffsetAlignmentBytes);
13448     size += vn_sizeof_VkBool32(&val->uniformTexelBufferOffsetSingleTexelAlignment);
13449     return size;
13450 }
13451 
13452 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)13453 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13454 {
13455     size_t size = 0;
13456 
13457     size += vn_sizeof_VkStructureType(&val->sType);
13458     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(val->pNext);
13459     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self(val);
13460 
13461     return size;
13462 }
13463 
13464 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(struct vn_cs_decoder * dec,const void * val)13465 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(struct vn_cs_decoder *dec, const void *val)
13466 {
13467     /* no known/supported struct */
13468     if (vn_decode_simple_pointer(dec))
13469         assert(false);
13470 }
13471 
13472 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentProperties * val)13473 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13474 {
13475     /* skip val->{sType,pNext} */
13476     vn_decode_VkDeviceSize(dec, &val->storageTexelBufferOffsetAlignmentBytes);
13477     vn_decode_VkBool32(dec, &val->storageTexelBufferOffsetSingleTexelAlignment);
13478     vn_decode_VkDeviceSize(dec, &val->uniformTexelBufferOffsetAlignmentBytes);
13479     vn_decode_VkBool32(dec, &val->uniformTexelBufferOffsetSingleTexelAlignment);
13480 }
13481 
13482 static inline void
vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceTexelBufferAlignmentProperties * val)13483 vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13484 {
13485     VkStructureType stype;
13486     vn_decode_VkStructureType(dec, &stype);
13487     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
13488 
13489     assert(val->sType == stype);
13490     vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext(dec, val->pNext);
13491     vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(dec, val);
13492 }
13493 
13494 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(const void * val)13495 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(const void *val)
13496 {
13497     /* no known/supported struct */
13498     return vn_sizeof_simple_pointer(NULL);
13499 }
13500 
13501 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)13502 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13503 {
13504     size_t size = 0;
13505     /* skip val->{sType,pNext} */
13506     /* skip val->storageTexelBufferOffsetAlignmentBytes */
13507     /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
13508     /* skip val->uniformTexelBufferOffsetAlignmentBytes */
13509     /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
13510     return size;
13511 }
13512 
13513 static inline size_t
vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties * val)13514 vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13515 {
13516     size_t size = 0;
13517 
13518     size += vn_sizeof_VkStructureType(&val->sType);
13519     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(val->pNext);
13520     size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(val);
13521 
13522     return size;
13523 }
13524 
13525 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)13526 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13527 {
13528     /* no known/supported struct */
13529     vn_encode_simple_pointer(enc, NULL);
13530 }
13531 
13532 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentProperties * val)13533 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13534 {
13535     /* skip val->{sType,pNext} */
13536     /* skip val->storageTexelBufferOffsetAlignmentBytes */
13537     /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
13538     /* skip val->uniformTexelBufferOffsetAlignmentBytes */
13539     /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
13540 }
13541 
13542 static inline void
vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceTexelBufferAlignmentProperties * val)13543 vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceTexelBufferAlignmentProperties *val)
13544 {
13545     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
13546     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES });
13547     vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_pnext_partial(enc, val->pNext);
13548     vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(enc, val);
13549 }
13550 
13551 /* struct VkPhysicalDeviceSubgroupSizeControlProperties chain */
13552 
13553 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(const void * val)13554 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(const void *val)
13555 {
13556     /* no known/supported struct */
13557     return vn_sizeof_simple_pointer(NULL);
13558 }
13559 
13560 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(const VkPhysicalDeviceSubgroupSizeControlProperties * val)13561 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
13562 {
13563     size_t size = 0;
13564     /* skip val->{sType,pNext} */
13565     size += vn_sizeof_uint32_t(&val->minSubgroupSize);
13566     size += vn_sizeof_uint32_t(&val->maxSubgroupSize);
13567     size += vn_sizeof_uint32_t(&val->maxComputeWorkgroupSubgroups);
13568     size += vn_sizeof_VkFlags(&val->requiredSubgroupSizeStages);
13569     return size;
13570 }
13571 
13572 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties * val)13573 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
13574 {
13575     size_t size = 0;
13576 
13577     size += vn_sizeof_VkStructureType(&val->sType);
13578     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(val->pNext);
13579     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self(val);
13580 
13581     return size;
13582 }
13583 
13584 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(struct vn_cs_decoder * dec,const void * val)13585 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(struct vn_cs_decoder *dec, const void *val)
13586 {
13587     /* no known/supported struct */
13588     if (vn_decode_simple_pointer(dec))
13589         assert(false);
13590 }
13591 
13592 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlProperties * val)13593 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlProperties *val)
13594 {
13595     /* skip val->{sType,pNext} */
13596     vn_decode_uint32_t(dec, &val->minSubgroupSize);
13597     vn_decode_uint32_t(dec, &val->maxSubgroupSize);
13598     vn_decode_uint32_t(dec, &val->maxComputeWorkgroupSubgroups);
13599     vn_decode_VkFlags(dec, &val->requiredSubgroupSizeStages);
13600 }
13601 
13602 static inline void
vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceSubgroupSizeControlProperties * val)13603 vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceSubgroupSizeControlProperties *val)
13604 {
13605     VkStructureType stype;
13606     vn_decode_VkStructureType(dec, &stype);
13607     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
13608 
13609     assert(val->sType == stype);
13610     vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext(dec, val->pNext);
13611     vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(dec, val);
13612 }
13613 
13614 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(const void * val)13615 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(const void *val)
13616 {
13617     /* no known/supported struct */
13618     return vn_sizeof_simple_pointer(NULL);
13619 }
13620 
13621 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(const VkPhysicalDeviceSubgroupSizeControlProperties * val)13622 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
13623 {
13624     size_t size = 0;
13625     /* skip val->{sType,pNext} */
13626     /* skip val->minSubgroupSize */
13627     /* skip val->maxSubgroupSize */
13628     /* skip val->maxComputeWorkgroupSubgroups */
13629     /* skip val->requiredSubgroupSizeStages */
13630     return size;
13631 }
13632 
13633 static inline size_t
vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_partial(const VkPhysicalDeviceSubgroupSizeControlProperties * val)13634 vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_partial(const VkPhysicalDeviceSubgroupSizeControlProperties *val)
13635 {
13636     size_t size = 0;
13637 
13638     size += vn_sizeof_VkStructureType(&val->sType);
13639     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(val->pNext);
13640     size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(val);
13641 
13642     return size;
13643 }
13644 
13645 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)13646 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13647 {
13648     /* no known/supported struct */
13649     vn_encode_simple_pointer(enc, NULL);
13650 }
13651 
13652 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlProperties * val)13653 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlProperties *val)
13654 {
13655     /* skip val->{sType,pNext} */
13656     /* skip val->minSubgroupSize */
13657     /* skip val->maxSubgroupSize */
13658     /* skip val->maxComputeWorkgroupSubgroups */
13659     /* skip val->requiredSubgroupSizeStages */
13660 }
13661 
13662 static inline void
vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceSubgroupSizeControlProperties * val)13663 vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceSubgroupSizeControlProperties *val)
13664 {
13665     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
13666     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES });
13667     vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_pnext_partial(enc, val->pNext);
13668     vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(enc, val);
13669 }
13670 
13671 /* struct VkPhysicalDeviceLineRasterizationPropertiesEXT chain */
13672 
13673 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(const void * val)13674 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(const void *val)
13675 {
13676     /* no known/supported struct */
13677     return vn_sizeof_simple_pointer(NULL);
13678 }
13679 
13680 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13681 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13682 {
13683     size_t size = 0;
13684     /* skip val->{sType,pNext} */
13685     size += vn_sizeof_uint32_t(&val->lineSubPixelPrecisionBits);
13686     return size;
13687 }
13688 
13689 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13690 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13691 {
13692     size_t size = 0;
13693 
13694     size += vn_sizeof_VkStructureType(&val->sType);
13695     size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(val->pNext);
13696     size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(val);
13697 
13698     return size;
13699 }
13700 
13701 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)13702 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
13703 {
13704     /* no known/supported struct */
13705     if (vn_decode_simple_pointer(dec))
13706         assert(false);
13707 }
13708 
13709 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13710 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13711 {
13712     /* skip val->{sType,pNext} */
13713     vn_decode_uint32_t(dec, &val->lineSubPixelPrecisionBits);
13714 }
13715 
13716 static inline void
vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13717 vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13718 {
13719     VkStructureType stype;
13720     vn_decode_VkStructureType(dec, &stype);
13721     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
13722 
13723     assert(val->sType == stype);
13724     vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext(dec, val->pNext);
13725     vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(dec, val);
13726 }
13727 
13728 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(const void * val)13729 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(const void *val)
13730 {
13731     /* no known/supported struct */
13732     return vn_sizeof_simple_pointer(NULL);
13733 }
13734 
13735 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13736 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13737 {
13738     size_t size = 0;
13739     /* skip val->{sType,pNext} */
13740     /* skip val->lineSubPixelPrecisionBits */
13741     return size;
13742 }
13743 
13744 static inline size_t
vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13745 vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13746 {
13747     size_t size = 0;
13748 
13749     size += vn_sizeof_VkStructureType(&val->sType);
13750     size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(val->pNext);
13751     size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(val);
13752 
13753     return size;
13754 }
13755 
13756 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)13757 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13758 {
13759     /* no known/supported struct */
13760     vn_encode_simple_pointer(enc, NULL);
13761 }
13762 
13763 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13764 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13765 {
13766     /* skip val->{sType,pNext} */
13767     /* skip val->lineSubPixelPrecisionBits */
13768 }
13769 
13770 static inline void
vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceLineRasterizationPropertiesEXT * val)13771 vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceLineRasterizationPropertiesEXT *val)
13772 {
13773     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
13774     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT });
13775     vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_pnext_partial(enc, val->pNext);
13776     vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(enc, val);
13777 }
13778 
13779 /* struct VkPhysicalDeviceVulkan11Properties chain */
13780 
13781 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void * val)13782 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(const void *val)
13783 {
13784     /* no known/supported struct */
13785     return vn_sizeof_simple_pointer(NULL);
13786 }
13787 
13788 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties * val)13789 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(const VkPhysicalDeviceVulkan11Properties *val)
13790 {
13791     size_t size = 0;
13792     /* skip val->{sType,pNext} */
13793     size += vn_sizeof_array_size(VK_UUID_SIZE);
13794     size += vn_sizeof_uint8_t_array(val->deviceUUID, VK_UUID_SIZE);
13795     size += vn_sizeof_array_size(VK_UUID_SIZE);
13796     size += vn_sizeof_uint8_t_array(val->driverUUID, VK_UUID_SIZE);
13797     size += vn_sizeof_array_size(VK_LUID_SIZE);
13798     size += vn_sizeof_uint8_t_array(val->deviceLUID, VK_LUID_SIZE);
13799     size += vn_sizeof_uint32_t(&val->deviceNodeMask);
13800     size += vn_sizeof_VkBool32(&val->deviceLUIDValid);
13801     size += vn_sizeof_uint32_t(&val->subgroupSize);
13802     size += vn_sizeof_VkFlags(&val->subgroupSupportedStages);
13803     size += vn_sizeof_VkFlags(&val->subgroupSupportedOperations);
13804     size += vn_sizeof_VkBool32(&val->subgroupQuadOperationsInAllStages);
13805     size += vn_sizeof_VkPointClippingBehavior(&val->pointClippingBehavior);
13806     size += vn_sizeof_uint32_t(&val->maxMultiviewViewCount);
13807     size += vn_sizeof_uint32_t(&val->maxMultiviewInstanceIndex);
13808     size += vn_sizeof_VkBool32(&val->protectedNoFault);
13809     size += vn_sizeof_uint32_t(&val->maxPerSetDescriptors);
13810     size += vn_sizeof_VkDeviceSize(&val->maxMemoryAllocationSize);
13811     return size;
13812 }
13813 
13814 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties * val)13815 vn_sizeof_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties *val)
13816 {
13817     size_t size = 0;
13818 
13819     size += vn_sizeof_VkStructureType(&val->sType);
13820     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext(val->pNext);
13821     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self(val);
13822 
13823     return size;
13824 }
13825 
13826 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder * dec,const void * val)13827 vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(struct vn_cs_decoder *dec, const void *val)
13828 {
13829     /* no known/supported struct */
13830     if (vn_decode_simple_pointer(dec))
13831         assert(false);
13832 }
13833 
13834 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)13835 vn_decode_VkPhysicalDeviceVulkan11Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
13836 {
13837     /* skip val->{sType,pNext} */
13838     {
13839         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
13840         vn_decode_uint8_t_array(dec, val->deviceUUID, array_size);
13841     }
13842     {
13843         const size_t array_size = vn_decode_array_size(dec, VK_UUID_SIZE);
13844         vn_decode_uint8_t_array(dec, val->driverUUID, array_size);
13845     }
13846     {
13847         const size_t array_size = vn_decode_array_size(dec, VK_LUID_SIZE);
13848         vn_decode_uint8_t_array(dec, val->deviceLUID, array_size);
13849     }
13850     vn_decode_uint32_t(dec, &val->deviceNodeMask);
13851     vn_decode_VkBool32(dec, &val->deviceLUIDValid);
13852     vn_decode_uint32_t(dec, &val->subgroupSize);
13853     vn_decode_VkFlags(dec, &val->subgroupSupportedStages);
13854     vn_decode_VkFlags(dec, &val->subgroupSupportedOperations);
13855     vn_decode_VkBool32(dec, &val->subgroupQuadOperationsInAllStages);
13856     vn_decode_VkPointClippingBehavior(dec, &val->pointClippingBehavior);
13857     vn_decode_uint32_t(dec, &val->maxMultiviewViewCount);
13858     vn_decode_uint32_t(dec, &val->maxMultiviewInstanceIndex);
13859     vn_decode_VkBool32(dec, &val->protectedNoFault);
13860     vn_decode_uint32_t(dec, &val->maxPerSetDescriptors);
13861     vn_decode_VkDeviceSize(dec, &val->maxMemoryAllocationSize);
13862 }
13863 
13864 static inline void
vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan11Properties * val)13865 vn_decode_VkPhysicalDeviceVulkan11Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan11Properties *val)
13866 {
13867     VkStructureType stype;
13868     vn_decode_VkStructureType(dec, &stype);
13869     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
13870 
13871     assert(val->sType == stype);
13872     vn_decode_VkPhysicalDeviceVulkan11Properties_pnext(dec, val->pNext);
13873     vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, val);
13874 }
13875 
13876 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void * val)13877 vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(const void *val)
13878 {
13879     /* no known/supported struct */
13880     return vn_sizeof_simple_pointer(NULL);
13881 }
13882 
13883 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties * val)13884 vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(const VkPhysicalDeviceVulkan11Properties *val)
13885 {
13886     size_t size = 0;
13887     /* skip val->{sType,pNext} */
13888     /* skip val->deviceUUID */
13889     /* skip val->driverUUID */
13890     /* skip val->deviceLUID */
13891     /* skip val->deviceNodeMask */
13892     /* skip val->deviceLUIDValid */
13893     /* skip val->subgroupSize */
13894     /* skip val->subgroupSupportedStages */
13895     /* skip val->subgroupSupportedOperations */
13896     /* skip val->subgroupQuadOperationsInAllStages */
13897     /* skip val->pointClippingBehavior */
13898     /* skip val->maxMultiviewViewCount */
13899     /* skip val->maxMultiviewInstanceIndex */
13900     /* skip val->protectedNoFault */
13901     /* skip val->maxPerSetDescriptors */
13902     /* skip val->maxMemoryAllocationSize */
13903     return size;
13904 }
13905 
13906 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties * val)13907 vn_sizeof_VkPhysicalDeviceVulkan11Properties_partial(const VkPhysicalDeviceVulkan11Properties *val)
13908 {
13909     size_t size = 0;
13910 
13911     size += vn_sizeof_VkStructureType(&val->sType);
13912     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_pnext_partial(val->pNext);
13913     size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial(val);
13914 
13915     return size;
13916 }
13917 
13918 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)13919 vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
13920 {
13921     /* no known/supported struct */
13922     vn_encode_simple_pointer(enc, NULL);
13923 }
13924 
13925 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)13926 vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
13927 {
13928     /* skip val->{sType,pNext} */
13929     /* skip val->deviceUUID */
13930     /* skip val->driverUUID */
13931     /* skip val->deviceLUID */
13932     /* skip val->deviceNodeMask */
13933     /* skip val->deviceLUIDValid */
13934     /* skip val->subgroupSize */
13935     /* skip val->subgroupSupportedStages */
13936     /* skip val->subgroupSupportedOperations */
13937     /* skip val->subgroupQuadOperationsInAllStages */
13938     /* skip val->pointClippingBehavior */
13939     /* skip val->maxMultiviewViewCount */
13940     /* skip val->maxMultiviewInstanceIndex */
13941     /* skip val->protectedNoFault */
13942     /* skip val->maxPerSetDescriptors */
13943     /* skip val->maxMemoryAllocationSize */
13944 }
13945 
13946 static inline void
vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan11Properties * val)13947 vn_encode_VkPhysicalDeviceVulkan11Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan11Properties *val)
13948 {
13949     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
13950     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES });
13951     vn_encode_VkPhysicalDeviceVulkan11Properties_pnext_partial(enc, val->pNext);
13952     vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, val);
13953 }
13954 
13955 /* struct VkPhysicalDeviceVulkan12Properties chain */
13956 
13957 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void * val)13958 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(const void *val)
13959 {
13960     /* no known/supported struct */
13961     return vn_sizeof_simple_pointer(NULL);
13962 }
13963 
13964 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties * val)13965 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(const VkPhysicalDeviceVulkan12Properties *val)
13966 {
13967     size_t size = 0;
13968     /* skip val->{sType,pNext} */
13969     size += vn_sizeof_VkDriverId(&val->driverID);
13970     size += vn_sizeof_array_size(VK_MAX_DRIVER_NAME_SIZE);
13971     size += vn_sizeof_char_array(val->driverName, VK_MAX_DRIVER_NAME_SIZE);
13972     size += vn_sizeof_array_size(VK_MAX_DRIVER_INFO_SIZE);
13973     size += vn_sizeof_char_array(val->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
13974     size += vn_sizeof_VkConformanceVersion(&val->conformanceVersion);
13975     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->denormBehaviorIndependence);
13976     size += vn_sizeof_VkShaderFloatControlsIndependence(&val->roundingModeIndependence);
13977     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat16);
13978     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat32);
13979     size += vn_sizeof_VkBool32(&val->shaderSignedZeroInfNanPreserveFloat64);
13980     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat16);
13981     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat32);
13982     size += vn_sizeof_VkBool32(&val->shaderDenormPreserveFloat64);
13983     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat16);
13984     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat32);
13985     size += vn_sizeof_VkBool32(&val->shaderDenormFlushToZeroFloat64);
13986     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat16);
13987     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat32);
13988     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTEFloat64);
13989     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat16);
13990     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat32);
13991     size += vn_sizeof_VkBool32(&val->shaderRoundingModeRTZFloat64);
13992     size += vn_sizeof_uint32_t(&val->maxUpdateAfterBindDescriptorsInAllPools);
13993     size += vn_sizeof_VkBool32(&val->shaderUniformBufferArrayNonUniformIndexingNative);
13994     size += vn_sizeof_VkBool32(&val->shaderSampledImageArrayNonUniformIndexingNative);
13995     size += vn_sizeof_VkBool32(&val->shaderStorageBufferArrayNonUniformIndexingNative);
13996     size += vn_sizeof_VkBool32(&val->shaderStorageImageArrayNonUniformIndexingNative);
13997     size += vn_sizeof_VkBool32(&val->shaderInputAttachmentArrayNonUniformIndexingNative);
13998     size += vn_sizeof_VkBool32(&val->robustBufferAccessUpdateAfterBind);
13999     size += vn_sizeof_VkBool32(&val->quadDivergentImplicitLod);
14000     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSamplers);
14001     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
14002     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
14003     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindSampledImages);
14004     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindStorageImages);
14005     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
14006     size += vn_sizeof_uint32_t(&val->maxPerStageUpdateAfterBindResources);
14007     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSamplers);
14008     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffers);
14009     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
14010     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffers);
14011     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
14012     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindSampledImages);
14013     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindStorageImages);
14014     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInputAttachments);
14015     size += vn_sizeof_VkFlags(&val->supportedDepthResolveModes);
14016     size += vn_sizeof_VkFlags(&val->supportedStencilResolveModes);
14017     size += vn_sizeof_VkBool32(&val->independentResolveNone);
14018     size += vn_sizeof_VkBool32(&val->independentResolve);
14019     size += vn_sizeof_VkBool32(&val->filterMinmaxSingleComponentFormats);
14020     size += vn_sizeof_VkBool32(&val->filterMinmaxImageComponentMapping);
14021     size += vn_sizeof_uint64_t(&val->maxTimelineSemaphoreValueDifference);
14022     size += vn_sizeof_VkFlags(&val->framebufferIntegerColorSampleCounts);
14023     return size;
14024 }
14025 
14026 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties * val)14027 vn_sizeof_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties *val)
14028 {
14029     size_t size = 0;
14030 
14031     size += vn_sizeof_VkStructureType(&val->sType);
14032     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext(val->pNext);
14033     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self(val);
14034 
14035     return size;
14036 }
14037 
14038 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder * dec,const void * val)14039 vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(struct vn_cs_decoder *dec, const void *val)
14040 {
14041     /* no known/supported struct */
14042     if (vn_decode_simple_pointer(dec))
14043         assert(false);
14044 }
14045 
14046 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)14047 vn_decode_VkPhysicalDeviceVulkan12Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
14048 {
14049     /* skip val->{sType,pNext} */
14050     vn_decode_VkDriverId(dec, &val->driverID);
14051     {
14052         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_NAME_SIZE);
14053         vn_decode_char_array(dec, val->driverName, array_size);
14054     }
14055     {
14056         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DRIVER_INFO_SIZE);
14057         vn_decode_char_array(dec, val->driverInfo, array_size);
14058     }
14059     vn_decode_VkConformanceVersion(dec, &val->conformanceVersion);
14060     vn_decode_VkShaderFloatControlsIndependence(dec, &val->denormBehaviorIndependence);
14061     vn_decode_VkShaderFloatControlsIndependence(dec, &val->roundingModeIndependence);
14062     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat16);
14063     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat32);
14064     vn_decode_VkBool32(dec, &val->shaderSignedZeroInfNanPreserveFloat64);
14065     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat16);
14066     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat32);
14067     vn_decode_VkBool32(dec, &val->shaderDenormPreserveFloat64);
14068     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat16);
14069     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat32);
14070     vn_decode_VkBool32(dec, &val->shaderDenormFlushToZeroFloat64);
14071     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat16);
14072     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat32);
14073     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTEFloat64);
14074     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat16);
14075     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat32);
14076     vn_decode_VkBool32(dec, &val->shaderRoundingModeRTZFloat64);
14077     vn_decode_uint32_t(dec, &val->maxUpdateAfterBindDescriptorsInAllPools);
14078     vn_decode_VkBool32(dec, &val->shaderUniformBufferArrayNonUniformIndexingNative);
14079     vn_decode_VkBool32(dec, &val->shaderSampledImageArrayNonUniformIndexingNative);
14080     vn_decode_VkBool32(dec, &val->shaderStorageBufferArrayNonUniformIndexingNative);
14081     vn_decode_VkBool32(dec, &val->shaderStorageImageArrayNonUniformIndexingNative);
14082     vn_decode_VkBool32(dec, &val->shaderInputAttachmentArrayNonUniformIndexingNative);
14083     vn_decode_VkBool32(dec, &val->robustBufferAccessUpdateAfterBind);
14084     vn_decode_VkBool32(dec, &val->quadDivergentImplicitLod);
14085     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSamplers);
14086     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindUniformBuffers);
14087     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageBuffers);
14088     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindSampledImages);
14089     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindStorageImages);
14090     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInputAttachments);
14091     vn_decode_uint32_t(dec, &val->maxPerStageUpdateAfterBindResources);
14092     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSamplers);
14093     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffers);
14094     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
14095     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffers);
14096     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
14097     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindSampledImages);
14098     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindStorageImages);
14099     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInputAttachments);
14100     vn_decode_VkFlags(dec, &val->supportedDepthResolveModes);
14101     vn_decode_VkFlags(dec, &val->supportedStencilResolveModes);
14102     vn_decode_VkBool32(dec, &val->independentResolveNone);
14103     vn_decode_VkBool32(dec, &val->independentResolve);
14104     vn_decode_VkBool32(dec, &val->filterMinmaxSingleComponentFormats);
14105     vn_decode_VkBool32(dec, &val->filterMinmaxImageComponentMapping);
14106     vn_decode_uint64_t(dec, &val->maxTimelineSemaphoreValueDifference);
14107     vn_decode_VkFlags(dec, &val->framebufferIntegerColorSampleCounts);
14108 }
14109 
14110 static inline void
vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan12Properties * val)14111 vn_decode_VkPhysicalDeviceVulkan12Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan12Properties *val)
14112 {
14113     VkStructureType stype;
14114     vn_decode_VkStructureType(dec, &stype);
14115     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
14116 
14117     assert(val->sType == stype);
14118     vn_decode_VkPhysicalDeviceVulkan12Properties_pnext(dec, val->pNext);
14119     vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, val);
14120 }
14121 
14122 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void * val)14123 vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(const void *val)
14124 {
14125     /* no known/supported struct */
14126     return vn_sizeof_simple_pointer(NULL);
14127 }
14128 
14129 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties * val)14130 vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(const VkPhysicalDeviceVulkan12Properties *val)
14131 {
14132     size_t size = 0;
14133     /* skip val->{sType,pNext} */
14134     /* skip val->driverID */
14135     /* skip val->driverName */
14136     /* skip val->driverInfo */
14137     size += vn_sizeof_VkConformanceVersion_partial(&val->conformanceVersion);
14138     /* skip val->denormBehaviorIndependence */
14139     /* skip val->roundingModeIndependence */
14140     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
14141     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
14142     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
14143     /* skip val->shaderDenormPreserveFloat16 */
14144     /* skip val->shaderDenormPreserveFloat32 */
14145     /* skip val->shaderDenormPreserveFloat64 */
14146     /* skip val->shaderDenormFlushToZeroFloat16 */
14147     /* skip val->shaderDenormFlushToZeroFloat32 */
14148     /* skip val->shaderDenormFlushToZeroFloat64 */
14149     /* skip val->shaderRoundingModeRTEFloat16 */
14150     /* skip val->shaderRoundingModeRTEFloat32 */
14151     /* skip val->shaderRoundingModeRTEFloat64 */
14152     /* skip val->shaderRoundingModeRTZFloat16 */
14153     /* skip val->shaderRoundingModeRTZFloat32 */
14154     /* skip val->shaderRoundingModeRTZFloat64 */
14155     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
14156     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
14157     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
14158     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
14159     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
14160     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
14161     /* skip val->robustBufferAccessUpdateAfterBind */
14162     /* skip val->quadDivergentImplicitLod */
14163     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
14164     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
14165     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
14166     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
14167     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
14168     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
14169     /* skip val->maxPerStageUpdateAfterBindResources */
14170     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
14171     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
14172     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
14173     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
14174     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
14175     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
14176     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
14177     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
14178     /* skip val->supportedDepthResolveModes */
14179     /* skip val->supportedStencilResolveModes */
14180     /* skip val->independentResolveNone */
14181     /* skip val->independentResolve */
14182     /* skip val->filterMinmaxSingleComponentFormats */
14183     /* skip val->filterMinmaxImageComponentMapping */
14184     /* skip val->maxTimelineSemaphoreValueDifference */
14185     /* skip val->framebufferIntegerColorSampleCounts */
14186     return size;
14187 }
14188 
14189 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties * val)14190 vn_sizeof_VkPhysicalDeviceVulkan12Properties_partial(const VkPhysicalDeviceVulkan12Properties *val)
14191 {
14192     size_t size = 0;
14193 
14194     size += vn_sizeof_VkStructureType(&val->sType);
14195     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_pnext_partial(val->pNext);
14196     size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial(val);
14197 
14198     return size;
14199 }
14200 
14201 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)14202 vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
14203 {
14204     /* no known/supported struct */
14205     vn_encode_simple_pointer(enc, NULL);
14206 }
14207 
14208 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)14209 vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
14210 {
14211     /* skip val->{sType,pNext} */
14212     /* skip val->driverID */
14213     /* skip val->driverName */
14214     /* skip val->driverInfo */
14215     vn_encode_VkConformanceVersion_partial(enc, &val->conformanceVersion);
14216     /* skip val->denormBehaviorIndependence */
14217     /* skip val->roundingModeIndependence */
14218     /* skip val->shaderSignedZeroInfNanPreserveFloat16 */
14219     /* skip val->shaderSignedZeroInfNanPreserveFloat32 */
14220     /* skip val->shaderSignedZeroInfNanPreserveFloat64 */
14221     /* skip val->shaderDenormPreserveFloat16 */
14222     /* skip val->shaderDenormPreserveFloat32 */
14223     /* skip val->shaderDenormPreserveFloat64 */
14224     /* skip val->shaderDenormFlushToZeroFloat16 */
14225     /* skip val->shaderDenormFlushToZeroFloat32 */
14226     /* skip val->shaderDenormFlushToZeroFloat64 */
14227     /* skip val->shaderRoundingModeRTEFloat16 */
14228     /* skip val->shaderRoundingModeRTEFloat32 */
14229     /* skip val->shaderRoundingModeRTEFloat64 */
14230     /* skip val->shaderRoundingModeRTZFloat16 */
14231     /* skip val->shaderRoundingModeRTZFloat32 */
14232     /* skip val->shaderRoundingModeRTZFloat64 */
14233     /* skip val->maxUpdateAfterBindDescriptorsInAllPools */
14234     /* skip val->shaderUniformBufferArrayNonUniformIndexingNative */
14235     /* skip val->shaderSampledImageArrayNonUniformIndexingNative */
14236     /* skip val->shaderStorageBufferArrayNonUniformIndexingNative */
14237     /* skip val->shaderStorageImageArrayNonUniformIndexingNative */
14238     /* skip val->shaderInputAttachmentArrayNonUniformIndexingNative */
14239     /* skip val->robustBufferAccessUpdateAfterBind */
14240     /* skip val->quadDivergentImplicitLod */
14241     /* skip val->maxPerStageDescriptorUpdateAfterBindSamplers */
14242     /* skip val->maxPerStageDescriptorUpdateAfterBindUniformBuffers */
14243     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageBuffers */
14244     /* skip val->maxPerStageDescriptorUpdateAfterBindSampledImages */
14245     /* skip val->maxPerStageDescriptorUpdateAfterBindStorageImages */
14246     /* skip val->maxPerStageDescriptorUpdateAfterBindInputAttachments */
14247     /* skip val->maxPerStageUpdateAfterBindResources */
14248     /* skip val->maxDescriptorSetUpdateAfterBindSamplers */
14249     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffers */
14250     /* skip val->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic */
14251     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffers */
14252     /* skip val->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic */
14253     /* skip val->maxDescriptorSetUpdateAfterBindSampledImages */
14254     /* skip val->maxDescriptorSetUpdateAfterBindStorageImages */
14255     /* skip val->maxDescriptorSetUpdateAfterBindInputAttachments */
14256     /* skip val->supportedDepthResolveModes */
14257     /* skip val->supportedStencilResolveModes */
14258     /* skip val->independentResolveNone */
14259     /* skip val->independentResolve */
14260     /* skip val->filterMinmaxSingleComponentFormats */
14261     /* skip val->filterMinmaxImageComponentMapping */
14262     /* skip val->maxTimelineSemaphoreValueDifference */
14263     /* skip val->framebufferIntegerColorSampleCounts */
14264 }
14265 
14266 static inline void
vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan12Properties * val)14267 vn_encode_VkPhysicalDeviceVulkan12Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan12Properties *val)
14268 {
14269     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
14270     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES });
14271     vn_encode_VkPhysicalDeviceVulkan12Properties_pnext_partial(enc, val->pNext);
14272     vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, val);
14273 }
14274 
14275 /* struct VkPhysicalDeviceVulkan13Properties chain */
14276 
14277 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(const void * val)14278 vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(const void *val)
14279 {
14280     /* no known/supported struct */
14281     return vn_sizeof_simple_pointer(NULL);
14282 }
14283 
14284 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(const VkPhysicalDeviceVulkan13Properties * val)14285 vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(const VkPhysicalDeviceVulkan13Properties *val)
14286 {
14287     size_t size = 0;
14288     /* skip val->{sType,pNext} */
14289     size += vn_sizeof_uint32_t(&val->minSubgroupSize);
14290     size += vn_sizeof_uint32_t(&val->maxSubgroupSize);
14291     size += vn_sizeof_uint32_t(&val->maxComputeWorkgroupSubgroups);
14292     size += vn_sizeof_VkFlags(&val->requiredSubgroupSizeStages);
14293     size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockSize);
14294     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorInlineUniformBlocks);
14295     size += vn_sizeof_uint32_t(&val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
14296     size += vn_sizeof_uint32_t(&val->maxDescriptorSetInlineUniformBlocks);
14297     size += vn_sizeof_uint32_t(&val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
14298     size += vn_sizeof_uint32_t(&val->maxInlineUniformTotalSize);
14299     size += vn_sizeof_VkBool32(&val->integerDotProduct8BitUnsignedAccelerated);
14300     size += vn_sizeof_VkBool32(&val->integerDotProduct8BitSignedAccelerated);
14301     size += vn_sizeof_VkBool32(&val->integerDotProduct8BitMixedSignednessAccelerated);
14302     size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedUnsignedAccelerated);
14303     size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedSignedAccelerated);
14304     size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
14305     size += vn_sizeof_VkBool32(&val->integerDotProduct16BitUnsignedAccelerated);
14306     size += vn_sizeof_VkBool32(&val->integerDotProduct16BitSignedAccelerated);
14307     size += vn_sizeof_VkBool32(&val->integerDotProduct16BitMixedSignednessAccelerated);
14308     size += vn_sizeof_VkBool32(&val->integerDotProduct32BitUnsignedAccelerated);
14309     size += vn_sizeof_VkBool32(&val->integerDotProduct32BitSignedAccelerated);
14310     size += vn_sizeof_VkBool32(&val->integerDotProduct32BitMixedSignednessAccelerated);
14311     size += vn_sizeof_VkBool32(&val->integerDotProduct64BitUnsignedAccelerated);
14312     size += vn_sizeof_VkBool32(&val->integerDotProduct64BitSignedAccelerated);
14313     size += vn_sizeof_VkBool32(&val->integerDotProduct64BitMixedSignednessAccelerated);
14314     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
14315     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
14316     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
14317     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
14318     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
14319     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
14320     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
14321     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
14322     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
14323     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
14324     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
14325     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
14326     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
14327     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
14328     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
14329     size += vn_sizeof_VkDeviceSize(&val->storageTexelBufferOffsetAlignmentBytes);
14330     size += vn_sizeof_VkBool32(&val->storageTexelBufferOffsetSingleTexelAlignment);
14331     size += vn_sizeof_VkDeviceSize(&val->uniformTexelBufferOffsetAlignmentBytes);
14332     size += vn_sizeof_VkBool32(&val->uniformTexelBufferOffsetSingleTexelAlignment);
14333     size += vn_sizeof_VkDeviceSize(&val->maxBufferSize);
14334     return size;
14335 }
14336 
14337 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties * val)14338 vn_sizeof_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties *val)
14339 {
14340     size_t size = 0;
14341 
14342     size += vn_sizeof_VkStructureType(&val->sType);
14343     size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext(val->pNext);
14344     size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self(val);
14345 
14346     return size;
14347 }
14348 
14349 static inline void
vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(struct vn_cs_decoder * dec,const void * val)14350 vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(struct vn_cs_decoder *dec, const void *val)
14351 {
14352     /* no known/supported struct */
14353     if (vn_decode_simple_pointer(dec))
14354         assert(false);
14355 }
14356 
14357 static inline void
vn_decode_VkPhysicalDeviceVulkan13Properties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Properties * val)14358 vn_decode_VkPhysicalDeviceVulkan13Properties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Properties *val)
14359 {
14360     /* skip val->{sType,pNext} */
14361     vn_decode_uint32_t(dec, &val->minSubgroupSize);
14362     vn_decode_uint32_t(dec, &val->maxSubgroupSize);
14363     vn_decode_uint32_t(dec, &val->maxComputeWorkgroupSubgroups);
14364     vn_decode_VkFlags(dec, &val->requiredSubgroupSizeStages);
14365     vn_decode_uint32_t(dec, &val->maxInlineUniformBlockSize);
14366     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorInlineUniformBlocks);
14367     vn_decode_uint32_t(dec, &val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
14368     vn_decode_uint32_t(dec, &val->maxDescriptorSetInlineUniformBlocks);
14369     vn_decode_uint32_t(dec, &val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
14370     vn_decode_uint32_t(dec, &val->maxInlineUniformTotalSize);
14371     vn_decode_VkBool32(dec, &val->integerDotProduct8BitUnsignedAccelerated);
14372     vn_decode_VkBool32(dec, &val->integerDotProduct8BitSignedAccelerated);
14373     vn_decode_VkBool32(dec, &val->integerDotProduct8BitMixedSignednessAccelerated);
14374     vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedUnsignedAccelerated);
14375     vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedSignedAccelerated);
14376     vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
14377     vn_decode_VkBool32(dec, &val->integerDotProduct16BitUnsignedAccelerated);
14378     vn_decode_VkBool32(dec, &val->integerDotProduct16BitSignedAccelerated);
14379     vn_decode_VkBool32(dec, &val->integerDotProduct16BitMixedSignednessAccelerated);
14380     vn_decode_VkBool32(dec, &val->integerDotProduct32BitUnsignedAccelerated);
14381     vn_decode_VkBool32(dec, &val->integerDotProduct32BitSignedAccelerated);
14382     vn_decode_VkBool32(dec, &val->integerDotProduct32BitMixedSignednessAccelerated);
14383     vn_decode_VkBool32(dec, &val->integerDotProduct64BitUnsignedAccelerated);
14384     vn_decode_VkBool32(dec, &val->integerDotProduct64BitSignedAccelerated);
14385     vn_decode_VkBool32(dec, &val->integerDotProduct64BitMixedSignednessAccelerated);
14386     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
14387     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
14388     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
14389     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
14390     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
14391     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
14392     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
14393     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
14394     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
14395     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
14396     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
14397     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
14398     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
14399     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
14400     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
14401     vn_decode_VkDeviceSize(dec, &val->storageTexelBufferOffsetAlignmentBytes);
14402     vn_decode_VkBool32(dec, &val->storageTexelBufferOffsetSingleTexelAlignment);
14403     vn_decode_VkDeviceSize(dec, &val->uniformTexelBufferOffsetAlignmentBytes);
14404     vn_decode_VkBool32(dec, &val->uniformTexelBufferOffsetSingleTexelAlignment);
14405     vn_decode_VkDeviceSize(dec, &val->maxBufferSize);
14406 }
14407 
14408 static inline void
vn_decode_VkPhysicalDeviceVulkan13Properties(struct vn_cs_decoder * dec,VkPhysicalDeviceVulkan13Properties * val)14409 vn_decode_VkPhysicalDeviceVulkan13Properties(struct vn_cs_decoder *dec, VkPhysicalDeviceVulkan13Properties *val)
14410 {
14411     VkStructureType stype;
14412     vn_decode_VkStructureType(dec, &stype);
14413     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
14414 
14415     assert(val->sType == stype);
14416     vn_decode_VkPhysicalDeviceVulkan13Properties_pnext(dec, val->pNext);
14417     vn_decode_VkPhysicalDeviceVulkan13Properties_self(dec, val);
14418 }
14419 
14420 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(const void * val)14421 vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(const void *val)
14422 {
14423     /* no known/supported struct */
14424     return vn_sizeof_simple_pointer(NULL);
14425 }
14426 
14427 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(const VkPhysicalDeviceVulkan13Properties * val)14428 vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(const VkPhysicalDeviceVulkan13Properties *val)
14429 {
14430     size_t size = 0;
14431     /* skip val->{sType,pNext} */
14432     /* skip val->minSubgroupSize */
14433     /* skip val->maxSubgroupSize */
14434     /* skip val->maxComputeWorkgroupSubgroups */
14435     /* skip val->requiredSubgroupSizeStages */
14436     /* skip val->maxInlineUniformBlockSize */
14437     /* skip val->maxPerStageDescriptorInlineUniformBlocks */
14438     /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
14439     /* skip val->maxDescriptorSetInlineUniformBlocks */
14440     /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
14441     /* skip val->maxInlineUniformTotalSize */
14442     /* skip val->integerDotProduct8BitUnsignedAccelerated */
14443     /* skip val->integerDotProduct8BitSignedAccelerated */
14444     /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
14445     /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
14446     /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
14447     /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
14448     /* skip val->integerDotProduct16BitUnsignedAccelerated */
14449     /* skip val->integerDotProduct16BitSignedAccelerated */
14450     /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
14451     /* skip val->integerDotProduct32BitUnsignedAccelerated */
14452     /* skip val->integerDotProduct32BitSignedAccelerated */
14453     /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
14454     /* skip val->integerDotProduct64BitUnsignedAccelerated */
14455     /* skip val->integerDotProduct64BitSignedAccelerated */
14456     /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
14457     /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
14458     /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
14459     /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
14460     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
14461     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
14462     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
14463     /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
14464     /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
14465     /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
14466     /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
14467     /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
14468     /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
14469     /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
14470     /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
14471     /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
14472     /* skip val->storageTexelBufferOffsetAlignmentBytes */
14473     /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
14474     /* skip val->uniformTexelBufferOffsetAlignmentBytes */
14475     /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
14476     /* skip val->maxBufferSize */
14477     return size;
14478 }
14479 
14480 static inline size_t
vn_sizeof_VkPhysicalDeviceVulkan13Properties_partial(const VkPhysicalDeviceVulkan13Properties * val)14481 vn_sizeof_VkPhysicalDeviceVulkan13Properties_partial(const VkPhysicalDeviceVulkan13Properties *val)
14482 {
14483     size_t size = 0;
14484 
14485     size += vn_sizeof_VkStructureType(&val->sType);
14486     size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_pnext_partial(val->pNext);
14487     size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial(val);
14488 
14489     return size;
14490 }
14491 
14492 static inline void
vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(struct vn_cs_encoder * enc,const void * val)14493 vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
14494 {
14495     /* no known/supported struct */
14496     vn_encode_simple_pointer(enc, NULL);
14497 }
14498 
14499 static inline void
vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Properties * val)14500 vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Properties *val)
14501 {
14502     /* skip val->{sType,pNext} */
14503     /* skip val->minSubgroupSize */
14504     /* skip val->maxSubgroupSize */
14505     /* skip val->maxComputeWorkgroupSubgroups */
14506     /* skip val->requiredSubgroupSizeStages */
14507     /* skip val->maxInlineUniformBlockSize */
14508     /* skip val->maxPerStageDescriptorInlineUniformBlocks */
14509     /* skip val->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks */
14510     /* skip val->maxDescriptorSetInlineUniformBlocks */
14511     /* skip val->maxDescriptorSetUpdateAfterBindInlineUniformBlocks */
14512     /* skip val->maxInlineUniformTotalSize */
14513     /* skip val->integerDotProduct8BitUnsignedAccelerated */
14514     /* skip val->integerDotProduct8BitSignedAccelerated */
14515     /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
14516     /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
14517     /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
14518     /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
14519     /* skip val->integerDotProduct16BitUnsignedAccelerated */
14520     /* skip val->integerDotProduct16BitSignedAccelerated */
14521     /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
14522     /* skip val->integerDotProduct32BitUnsignedAccelerated */
14523     /* skip val->integerDotProduct32BitSignedAccelerated */
14524     /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
14525     /* skip val->integerDotProduct64BitUnsignedAccelerated */
14526     /* skip val->integerDotProduct64BitSignedAccelerated */
14527     /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
14528     /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
14529     /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
14530     /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
14531     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
14532     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
14533     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
14534     /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
14535     /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
14536     /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
14537     /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
14538     /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
14539     /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
14540     /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
14541     /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
14542     /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
14543     /* skip val->storageTexelBufferOffsetAlignmentBytes */
14544     /* skip val->storageTexelBufferOffsetSingleTexelAlignment */
14545     /* skip val->uniformTexelBufferOffsetAlignmentBytes */
14546     /* skip val->uniformTexelBufferOffsetSingleTexelAlignment */
14547     /* skip val->maxBufferSize */
14548 }
14549 
14550 static inline void
vn_encode_VkPhysicalDeviceVulkan13Properties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceVulkan13Properties * val)14551 vn_encode_VkPhysicalDeviceVulkan13Properties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceVulkan13Properties *val)
14552 {
14553     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
14554     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES });
14555     vn_encode_VkPhysicalDeviceVulkan13Properties_pnext_partial(enc, val->pNext);
14556     vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(enc, val);
14557 }
14558 
14559 /* struct VkPhysicalDeviceCustomBorderColorPropertiesEXT chain */
14560 
14561 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(const void * val)14562 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(const void *val)
14563 {
14564     /* no known/supported struct */
14565     return vn_sizeof_simple_pointer(NULL);
14566 }
14567 
14568 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14569 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14570 {
14571     size_t size = 0;
14572     /* skip val->{sType,pNext} */
14573     size += vn_sizeof_uint32_t(&val->maxCustomBorderColorSamplers);
14574     return size;
14575 }
14576 
14577 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14578 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14579 {
14580     size_t size = 0;
14581 
14582     size += vn_sizeof_VkStructureType(&val->sType);
14583     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(val->pNext);
14584     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(val);
14585 
14586     return size;
14587 }
14588 
14589 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)14590 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
14591 {
14592     /* no known/supported struct */
14593     if (vn_decode_simple_pointer(dec))
14594         assert(false);
14595 }
14596 
14597 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14598 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14599 {
14600     /* skip val->{sType,pNext} */
14601     vn_decode_uint32_t(dec, &val->maxCustomBorderColorSamplers);
14602 }
14603 
14604 static inline void
vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14605 vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14606 {
14607     VkStructureType stype;
14608     vn_decode_VkStructureType(dec, &stype);
14609     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
14610 
14611     assert(val->sType == stype);
14612     vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext(dec, val->pNext);
14613     vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(dec, val);
14614 }
14615 
14616 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(const void * val)14617 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(const void *val)
14618 {
14619     /* no known/supported struct */
14620     return vn_sizeof_simple_pointer(NULL);
14621 }
14622 
14623 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14624 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14625 {
14626     size_t size = 0;
14627     /* skip val->{sType,pNext} */
14628     /* skip val->maxCustomBorderColorSamplers */
14629     return size;
14630 }
14631 
14632 static inline size_t
vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14633 vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14634 {
14635     size_t size = 0;
14636 
14637     size += vn_sizeof_VkStructureType(&val->sType);
14638     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(val->pNext);
14639     size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(val);
14640 
14641     return size;
14642 }
14643 
14644 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)14645 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
14646 {
14647     /* no known/supported struct */
14648     vn_encode_simple_pointer(enc, NULL);
14649 }
14650 
14651 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14652 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14653 {
14654     /* skip val->{sType,pNext} */
14655     /* skip val->maxCustomBorderColorSamplers */
14656 }
14657 
14658 static inline void
vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceCustomBorderColorPropertiesEXT * val)14659 vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *val)
14660 {
14661     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
14662     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT });
14663     vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_pnext_partial(enc, val->pNext);
14664     vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(enc, val);
14665 }
14666 
14667 /* struct VkPhysicalDeviceRobustness2PropertiesEXT chain */
14668 
14669 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(const void * val)14670 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(const void *val)
14671 {
14672     /* no known/supported struct */
14673     return vn_sizeof_simple_pointer(NULL);
14674 }
14675 
14676 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self(const VkPhysicalDeviceRobustness2PropertiesEXT * val)14677 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
14678 {
14679     size_t size = 0;
14680     /* skip val->{sType,pNext} */
14681     size += vn_sizeof_VkDeviceSize(&val->robustStorageBufferAccessSizeAlignment);
14682     size += vn_sizeof_VkDeviceSize(&val->robustUniformBufferAccessSizeAlignment);
14683     return size;
14684 }
14685 
14686 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT * val)14687 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
14688 {
14689     size_t size = 0;
14690 
14691     size += vn_sizeof_VkStructureType(&val->sType);
14692     size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(val->pNext);
14693     size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self(val);
14694 
14695     return size;
14696 }
14697 
14698 static inline void
vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)14699 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
14700 {
14701     /* no known/supported struct */
14702     if (vn_decode_simple_pointer(dec))
14703         assert(false);
14704 }
14705 
14706 static inline void
vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2PropertiesEXT * val)14707 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2PropertiesEXT *val)
14708 {
14709     /* skip val->{sType,pNext} */
14710     vn_decode_VkDeviceSize(dec, &val->robustStorageBufferAccessSizeAlignment);
14711     vn_decode_VkDeviceSize(dec, &val->robustUniformBufferAccessSizeAlignment);
14712 }
14713 
14714 static inline void
vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceRobustness2PropertiesEXT * val)14715 vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceRobustness2PropertiesEXT *val)
14716 {
14717     VkStructureType stype;
14718     vn_decode_VkStructureType(dec, &stype);
14719     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
14720 
14721     assert(val->sType == stype);
14722     vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext(dec, val->pNext);
14723     vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(dec, val);
14724 }
14725 
14726 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(const void * val)14727 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(const void *val)
14728 {
14729     /* no known/supported struct */
14730     return vn_sizeof_simple_pointer(NULL);
14731 }
14732 
14733 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(const VkPhysicalDeviceRobustness2PropertiesEXT * val)14734 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
14735 {
14736     size_t size = 0;
14737     /* skip val->{sType,pNext} */
14738     /* skip val->robustStorageBufferAccessSizeAlignment */
14739     /* skip val->robustUniformBufferAccessSizeAlignment */
14740     return size;
14741 }
14742 
14743 static inline size_t
vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_partial(const VkPhysicalDeviceRobustness2PropertiesEXT * val)14744 vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_partial(const VkPhysicalDeviceRobustness2PropertiesEXT *val)
14745 {
14746     size_t size = 0;
14747 
14748     size += vn_sizeof_VkStructureType(&val->sType);
14749     size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(val->pNext);
14750     size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(val);
14751 
14752     return size;
14753 }
14754 
14755 static inline void
vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)14756 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
14757 {
14758     /* no known/supported struct */
14759     vn_encode_simple_pointer(enc, NULL);
14760 }
14761 
14762 static inline void
vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2PropertiesEXT * val)14763 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2PropertiesEXT *val)
14764 {
14765     /* skip val->{sType,pNext} */
14766     /* skip val->robustStorageBufferAccessSizeAlignment */
14767     /* skip val->robustUniformBufferAccessSizeAlignment */
14768 }
14769 
14770 static inline void
vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceRobustness2PropertiesEXT * val)14771 vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceRobustness2PropertiesEXT *val)
14772 {
14773     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
14774     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT });
14775     vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_pnext_partial(enc, val->pNext);
14776     vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(enc, val);
14777 }
14778 
14779 /* struct VkPhysicalDeviceProvokingVertexPropertiesEXT chain */
14780 
14781 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(const void * val)14782 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(const void *val)
14783 {
14784     /* no known/supported struct */
14785     return vn_sizeof_simple_pointer(NULL);
14786 }
14787 
14788 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14789 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14790 {
14791     size_t size = 0;
14792     /* skip val->{sType,pNext} */
14793     size += vn_sizeof_VkBool32(&val->provokingVertexModePerPipeline);
14794     size += vn_sizeof_VkBool32(&val->transformFeedbackPreservesTriangleFanProvokingVertex);
14795     return size;
14796 }
14797 
14798 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14799 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14800 {
14801     size_t size = 0;
14802 
14803     size += vn_sizeof_VkStructureType(&val->sType);
14804     size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(val->pNext);
14805     size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(val);
14806 
14807     return size;
14808 }
14809 
14810 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(struct vn_cs_decoder * dec,const void * val)14811 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(struct vn_cs_decoder *dec, const void *val)
14812 {
14813     /* no known/supported struct */
14814     if (vn_decode_simple_pointer(dec))
14815         assert(false);
14816 }
14817 
14818 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14819 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14820 {
14821     /* skip val->{sType,pNext} */
14822     vn_decode_VkBool32(dec, &val->provokingVertexModePerPipeline);
14823     vn_decode_VkBool32(dec, &val->transformFeedbackPreservesTriangleFanProvokingVertex);
14824 }
14825 
14826 static inline void
vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT(struct vn_cs_decoder * dec,VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14827 vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT(struct vn_cs_decoder *dec, VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14828 {
14829     VkStructureType stype;
14830     vn_decode_VkStructureType(dec, &stype);
14831     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
14832 
14833     assert(val->sType == stype);
14834     vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext(dec, val->pNext);
14835     vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(dec, val);
14836 }
14837 
14838 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(const void * val)14839 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(const void *val)
14840 {
14841     /* no known/supported struct */
14842     return vn_sizeof_simple_pointer(NULL);
14843 }
14844 
14845 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14846 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14847 {
14848     size_t size = 0;
14849     /* skip val->{sType,pNext} */
14850     /* skip val->provokingVertexModePerPipeline */
14851     /* skip val->transformFeedbackPreservesTriangleFanProvokingVertex */
14852     return size;
14853 }
14854 
14855 static inline size_t
vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14856 vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14857 {
14858     size_t size = 0;
14859 
14860     size += vn_sizeof_VkStructureType(&val->sType);
14861     size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(val->pNext);
14862     size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(val);
14863 
14864     return size;
14865 }
14866 
14867 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)14868 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
14869 {
14870     /* no known/supported struct */
14871     vn_encode_simple_pointer(enc, NULL);
14872 }
14873 
14874 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14875 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14876 {
14877     /* skip val->{sType,pNext} */
14878     /* skip val->provokingVertexModePerPipeline */
14879     /* skip val->transformFeedbackPreservesTriangleFanProvokingVertex */
14880 }
14881 
14882 static inline void
vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProvokingVertexPropertiesEXT * val)14883 vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProvokingVertexPropertiesEXT *val)
14884 {
14885     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
14886     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT });
14887     vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_pnext_partial(enc, val->pNext);
14888     vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(enc, val);
14889 }
14890 
14891 /* struct VkPhysicalDeviceShaderIntegerDotProductProperties chain */
14892 
14893 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(const void * val)14894 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(const void *val)
14895 {
14896     /* no known/supported struct */
14897     return vn_sizeof_simple_pointer(NULL);
14898 }
14899 
14900 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)14901 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
14902 {
14903     size_t size = 0;
14904     /* skip val->{sType,pNext} */
14905     size += vn_sizeof_VkBool32(&val->integerDotProduct8BitUnsignedAccelerated);
14906     size += vn_sizeof_VkBool32(&val->integerDotProduct8BitSignedAccelerated);
14907     size += vn_sizeof_VkBool32(&val->integerDotProduct8BitMixedSignednessAccelerated);
14908     size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedUnsignedAccelerated);
14909     size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedSignedAccelerated);
14910     size += vn_sizeof_VkBool32(&val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
14911     size += vn_sizeof_VkBool32(&val->integerDotProduct16BitUnsignedAccelerated);
14912     size += vn_sizeof_VkBool32(&val->integerDotProduct16BitSignedAccelerated);
14913     size += vn_sizeof_VkBool32(&val->integerDotProduct16BitMixedSignednessAccelerated);
14914     size += vn_sizeof_VkBool32(&val->integerDotProduct32BitUnsignedAccelerated);
14915     size += vn_sizeof_VkBool32(&val->integerDotProduct32BitSignedAccelerated);
14916     size += vn_sizeof_VkBool32(&val->integerDotProduct32BitMixedSignednessAccelerated);
14917     size += vn_sizeof_VkBool32(&val->integerDotProduct64BitUnsignedAccelerated);
14918     size += vn_sizeof_VkBool32(&val->integerDotProduct64BitSignedAccelerated);
14919     size += vn_sizeof_VkBool32(&val->integerDotProduct64BitMixedSignednessAccelerated);
14920     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
14921     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
14922     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
14923     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
14924     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
14925     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
14926     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
14927     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
14928     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
14929     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
14930     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
14931     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
14932     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
14933     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
14934     size += vn_sizeof_VkBool32(&val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
14935     return size;
14936 }
14937 
14938 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)14939 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
14940 {
14941     size_t size = 0;
14942 
14943     size += vn_sizeof_VkStructureType(&val->sType);
14944     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(val->pNext);
14945     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self(val);
14946 
14947     return size;
14948 }
14949 
14950 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(struct vn_cs_decoder * dec,const void * val)14951 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(struct vn_cs_decoder *dec, const void *val)
14952 {
14953     /* no known/supported struct */
14954     if (vn_decode_simple_pointer(dec))
14955         assert(false);
14956 }
14957 
14958 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductProperties * val)14959 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductProperties *val)
14960 {
14961     /* skip val->{sType,pNext} */
14962     vn_decode_VkBool32(dec, &val->integerDotProduct8BitUnsignedAccelerated);
14963     vn_decode_VkBool32(dec, &val->integerDotProduct8BitSignedAccelerated);
14964     vn_decode_VkBool32(dec, &val->integerDotProduct8BitMixedSignednessAccelerated);
14965     vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedUnsignedAccelerated);
14966     vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedSignedAccelerated);
14967     vn_decode_VkBool32(dec, &val->integerDotProduct4x8BitPackedMixedSignednessAccelerated);
14968     vn_decode_VkBool32(dec, &val->integerDotProduct16BitUnsignedAccelerated);
14969     vn_decode_VkBool32(dec, &val->integerDotProduct16BitSignedAccelerated);
14970     vn_decode_VkBool32(dec, &val->integerDotProduct16BitMixedSignednessAccelerated);
14971     vn_decode_VkBool32(dec, &val->integerDotProduct32BitUnsignedAccelerated);
14972     vn_decode_VkBool32(dec, &val->integerDotProduct32BitSignedAccelerated);
14973     vn_decode_VkBool32(dec, &val->integerDotProduct32BitMixedSignednessAccelerated);
14974     vn_decode_VkBool32(dec, &val->integerDotProduct64BitUnsignedAccelerated);
14975     vn_decode_VkBool32(dec, &val->integerDotProduct64BitSignedAccelerated);
14976     vn_decode_VkBool32(dec, &val->integerDotProduct64BitMixedSignednessAccelerated);
14977     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
14978     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitSignedAccelerated);
14979     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
14980     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
14981     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
14982     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
14983     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
14984     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitSignedAccelerated);
14985     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
14986     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
14987     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitSignedAccelerated);
14988     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
14989     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
14990     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitSignedAccelerated);
14991     vn_decode_VkBool32(dec, &val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
14992 }
14993 
14994 static inline void
vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceShaderIntegerDotProductProperties * val)14995 vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceShaderIntegerDotProductProperties *val)
14996 {
14997     VkStructureType stype;
14998     vn_decode_VkStructureType(dec, &stype);
14999     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
15000 
15001     assert(val->sType == stype);
15002     vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext(dec, val->pNext);
15003     vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(dec, val);
15004 }
15005 
15006 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(const void * val)15007 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(const void *val)
15008 {
15009     /* no known/supported struct */
15010     return vn_sizeof_simple_pointer(NULL);
15011 }
15012 
15013 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)15014 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
15015 {
15016     size_t size = 0;
15017     /* skip val->{sType,pNext} */
15018     /* skip val->integerDotProduct8BitUnsignedAccelerated */
15019     /* skip val->integerDotProduct8BitSignedAccelerated */
15020     /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
15021     /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
15022     /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
15023     /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
15024     /* skip val->integerDotProduct16BitUnsignedAccelerated */
15025     /* skip val->integerDotProduct16BitSignedAccelerated */
15026     /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
15027     /* skip val->integerDotProduct32BitUnsignedAccelerated */
15028     /* skip val->integerDotProduct32BitSignedAccelerated */
15029     /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
15030     /* skip val->integerDotProduct64BitUnsignedAccelerated */
15031     /* skip val->integerDotProduct64BitSignedAccelerated */
15032     /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
15033     /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
15034     /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
15035     /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
15036     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
15037     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
15038     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
15039     /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
15040     /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
15041     /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
15042     /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
15043     /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
15044     /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
15045     /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
15046     /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
15047     /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
15048     return size;
15049 }
15050 
15051 static inline size_t
vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties * val)15052 vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
15053 {
15054     size_t size = 0;
15055 
15056     size += vn_sizeof_VkStructureType(&val->sType);
15057     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(val->pNext);
15058     size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(val);
15059 
15060     return size;
15061 }
15062 
15063 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)15064 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15065 {
15066     /* no known/supported struct */
15067     vn_encode_simple_pointer(enc, NULL);
15068 }
15069 
15070 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductProperties * val)15071 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
15072 {
15073     /* skip val->{sType,pNext} */
15074     /* skip val->integerDotProduct8BitUnsignedAccelerated */
15075     /* skip val->integerDotProduct8BitSignedAccelerated */
15076     /* skip val->integerDotProduct8BitMixedSignednessAccelerated */
15077     /* skip val->integerDotProduct4x8BitPackedUnsignedAccelerated */
15078     /* skip val->integerDotProduct4x8BitPackedSignedAccelerated */
15079     /* skip val->integerDotProduct4x8BitPackedMixedSignednessAccelerated */
15080     /* skip val->integerDotProduct16BitUnsignedAccelerated */
15081     /* skip val->integerDotProduct16BitSignedAccelerated */
15082     /* skip val->integerDotProduct16BitMixedSignednessAccelerated */
15083     /* skip val->integerDotProduct32BitUnsignedAccelerated */
15084     /* skip val->integerDotProduct32BitSignedAccelerated */
15085     /* skip val->integerDotProduct32BitMixedSignednessAccelerated */
15086     /* skip val->integerDotProduct64BitUnsignedAccelerated */
15087     /* skip val->integerDotProduct64BitSignedAccelerated */
15088     /* skip val->integerDotProduct64BitMixedSignednessAccelerated */
15089     /* skip val->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated */
15090     /* skip val->integerDotProductAccumulatingSaturating8BitSignedAccelerated */
15091     /* skip val->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated */
15092     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated */
15093     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated */
15094     /* skip val->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated */
15095     /* skip val->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated */
15096     /* skip val->integerDotProductAccumulatingSaturating16BitSignedAccelerated */
15097     /* skip val->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated */
15098     /* skip val->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated */
15099     /* skip val->integerDotProductAccumulatingSaturating32BitSignedAccelerated */
15100     /* skip val->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated */
15101     /* skip val->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated */
15102     /* skip val->integerDotProductAccumulatingSaturating64BitSignedAccelerated */
15103     /* skip val->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated */
15104 }
15105 
15106 static inline void
vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceShaderIntegerDotProductProperties * val)15107 vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceShaderIntegerDotProductProperties *val)
15108 {
15109     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
15110     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES });
15111     vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_pnext_partial(enc, val->pNext);
15112     vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(enc, val);
15113 }
15114 
15115 /* struct VkPhysicalDeviceProperties2 chain */
15116 
15117 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void * val)15118 vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val)
15119 {
15120     const VkBaseInStructure *pnext = val;
15121     size_t size = 0;
15122 
15123     while (pnext) {
15124         switch ((int32_t)pnext->sType) {
15125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
15126             size += vn_sizeof_simple_pointer(pnext);
15127             size += vn_sizeof_VkStructureType(&pnext->sType);
15128             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15129             size += vn_sizeof_VkPhysicalDeviceDriverProperties_self((const VkPhysicalDeviceDriverProperties *)pnext);
15130             return size;
15131         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
15132             size += vn_sizeof_simple_pointer(pnext);
15133             size += vn_sizeof_VkStructureType(&pnext->sType);
15134             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15135             size += vn_sizeof_VkPhysicalDeviceIDProperties_self((const VkPhysicalDeviceIDProperties *)pnext);
15136             return size;
15137         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
15138             size += vn_sizeof_simple_pointer(pnext);
15139             size += vn_sizeof_VkStructureType(&pnext->sType);
15140             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15141             size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self((const VkPhysicalDeviceMultiviewProperties *)pnext);
15142             return size;
15143         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
15144             size += vn_sizeof_simple_pointer(pnext);
15145             size += vn_sizeof_VkStructureType(&pnext->sType);
15146             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15147             size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self((const VkPhysicalDeviceSubgroupProperties *)pnext);
15148             return size;
15149         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
15150             size += vn_sizeof_simple_pointer(pnext);
15151             size += vn_sizeof_VkStructureType(&pnext->sType);
15152             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15153             size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self((const VkPhysicalDevicePointClippingProperties *)pnext);
15154             return size;
15155         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
15156             size += vn_sizeof_simple_pointer(pnext);
15157             size += vn_sizeof_VkStructureType(&pnext->sType);
15158             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15159             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
15160             return size;
15161         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
15162             size += vn_sizeof_simple_pointer(pnext);
15163             size += vn_sizeof_VkStructureType(&pnext->sType);
15164             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15165             size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
15166             return size;
15167         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
15168             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
15169                 break;
15170             size += vn_sizeof_simple_pointer(pnext);
15171             size += vn_sizeof_VkStructureType(&pnext->sType);
15172             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15173             size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self((const VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
15174             return size;
15175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
15176             size += vn_sizeof_simple_pointer(pnext);
15177             size += vn_sizeof_VkStructureType(&pnext->sType);
15178             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15179             size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self((const VkPhysicalDeviceMaintenance3Properties *)pnext);
15180             return size;
15181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
15182             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
15183                 break;
15184             size += vn_sizeof_simple_pointer(pnext);
15185             size += vn_sizeof_VkStructureType(&pnext->sType);
15186             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15187             size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self((const VkPhysicalDeviceMaintenance4Properties *)pnext);
15188             return size;
15189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
15190             size += vn_sizeof_simple_pointer(pnext);
15191             size += vn_sizeof_VkStructureType(&pnext->sType);
15192             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15193             size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self((const VkPhysicalDeviceFloatControlsProperties *)pnext);
15194             return size;
15195         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
15196             if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
15197                 break;
15198             size += vn_sizeof_simple_pointer(pnext);
15199             size += vn_sizeof_VkStructureType(&pnext->sType);
15200             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15201             size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self((const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
15202             return size;
15203         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
15204             size += vn_sizeof_simple_pointer(pnext);
15205             size += vn_sizeof_VkStructureType(&pnext->sType);
15206             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15207             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
15208             return size;
15209         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
15210             size += vn_sizeof_simple_pointer(pnext);
15211             size += vn_sizeof_VkStructureType(&pnext->sType);
15212             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15213             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
15214             return size;
15215         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
15216             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
15217                 break;
15218             size += vn_sizeof_simple_pointer(pnext);
15219             size += vn_sizeof_VkStructureType(&pnext->sType);
15220             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15221             size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self((const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
15222             return size;
15223         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
15224             size += vn_sizeof_simple_pointer(pnext);
15225             size += vn_sizeof_VkStructureType(&pnext->sType);
15226             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15227             size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
15228             return size;
15229         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
15230             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
15231                 break;
15232             size += vn_sizeof_simple_pointer(pnext);
15233             size += vn_sizeof_VkStructureType(&pnext->sType);
15234             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15235             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
15236             return size;
15237         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
15238             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
15239                 break;
15240             size += vn_sizeof_simple_pointer(pnext);
15241             size += vn_sizeof_VkStructureType(&pnext->sType);
15242             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15243             size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self((const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
15244             return size;
15245         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
15246             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
15247                 break;
15248             size += vn_sizeof_simple_pointer(pnext);
15249             size += vn_sizeof_VkStructureType(&pnext->sType);
15250             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15251             size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self((const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
15252             return size;
15253         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
15254             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
15255                 break;
15256             size += vn_sizeof_simple_pointer(pnext);
15257             size += vn_sizeof_VkStructureType(&pnext->sType);
15258             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15259             size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self((const VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
15260             return size;
15261         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
15262             size += vn_sizeof_simple_pointer(pnext);
15263             size += vn_sizeof_VkStructureType(&pnext->sType);
15264             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15265             size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self((const VkPhysicalDeviceVulkan11Properties *)pnext);
15266             return size;
15267         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
15268             size += vn_sizeof_simple_pointer(pnext);
15269             size += vn_sizeof_VkStructureType(&pnext->sType);
15270             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15271             size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self((const VkPhysicalDeviceVulkan12Properties *)pnext);
15272             return size;
15273         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
15274             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
15275                 break;
15276             size += vn_sizeof_simple_pointer(pnext);
15277             size += vn_sizeof_VkStructureType(&pnext->sType);
15278             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15279             size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self((const VkPhysicalDeviceVulkan13Properties *)pnext);
15280             return size;
15281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
15282             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
15283                 break;
15284             size += vn_sizeof_simple_pointer(pnext);
15285             size += vn_sizeof_VkStructureType(&pnext->sType);
15286             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15287             size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self((const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
15288             return size;
15289         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
15290             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
15291                 break;
15292             size += vn_sizeof_simple_pointer(pnext);
15293             size += vn_sizeof_VkStructureType(&pnext->sType);
15294             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15295             size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self((const VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
15296             return size;
15297         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
15298             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
15299                 break;
15300             size += vn_sizeof_simple_pointer(pnext);
15301             size += vn_sizeof_VkStructureType(&pnext->sType);
15302             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15303             size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self((const VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
15304             return size;
15305         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
15306             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
15307                 break;
15308             size += vn_sizeof_simple_pointer(pnext);
15309             size += vn_sizeof_VkStructureType(&pnext->sType);
15310             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
15311             size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self((const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
15312             return size;
15313         default:
15314             /* ignore unknown/unsupported struct */
15315             break;
15316         }
15317         pnext = pnext->pNext;
15318     }
15319 
15320     return vn_sizeof_simple_pointer(NULL);
15321 }
15322 
15323 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 * val)15324 vn_sizeof_VkPhysicalDeviceProperties2_self(const VkPhysicalDeviceProperties2 *val)
15325 {
15326     size_t size = 0;
15327     /* skip val->{sType,pNext} */
15328     size += vn_sizeof_VkPhysicalDeviceProperties(&val->properties);
15329     return size;
15330 }
15331 
15332 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 * val)15333 vn_sizeof_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2 *val)
15334 {
15335     size_t size = 0;
15336 
15337     size += vn_sizeof_VkStructureType(&val->sType);
15338     size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(val->pNext);
15339     size += vn_sizeof_VkPhysicalDeviceProperties2_self(val);
15340 
15341     return size;
15342 }
15343 
15344 static inline void
vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder * dec,const void * val)15345 vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
15346 {
15347     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
15348     VkStructureType stype;
15349 
15350     if (!vn_decode_simple_pointer(dec))
15351         return;
15352 
15353     vn_decode_VkStructureType(dec, &stype);
15354     while (true) {
15355         assert(pnext);
15356         if (pnext->sType == stype)
15357             break;
15358 
15359         pnext = pnext->pNext;
15360     }
15361 
15362     switch ((int32_t)pnext->sType) {
15363     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
15364         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15365         vn_decode_VkPhysicalDeviceDriverProperties_self(dec, (VkPhysicalDeviceDriverProperties *)pnext);
15366         break;
15367     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
15368         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15369         vn_decode_VkPhysicalDeviceIDProperties_self(dec, (VkPhysicalDeviceIDProperties *)pnext);
15370         break;
15371     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
15372         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15373         vn_decode_VkPhysicalDeviceMultiviewProperties_self(dec, (VkPhysicalDeviceMultiviewProperties *)pnext);
15374         break;
15375     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
15376         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15377         vn_decode_VkPhysicalDeviceSubgroupProperties_self(dec, (VkPhysicalDeviceSubgroupProperties *)pnext);
15378         break;
15379     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
15380         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15381         vn_decode_VkPhysicalDevicePointClippingProperties_self(dec, (VkPhysicalDevicePointClippingProperties *)pnext);
15382         break;
15383     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
15384         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15385         vn_decode_VkPhysicalDeviceProtectedMemoryProperties_self(dec, (VkPhysicalDeviceProtectedMemoryProperties *)pnext);
15386         break;
15387     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
15388         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15389         vn_decode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self(dec, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
15390         break;
15391     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
15392         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15393         vn_decode_VkPhysicalDeviceInlineUniformBlockProperties_self(dec, (VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
15394         break;
15395     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
15396         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15397         vn_decode_VkPhysicalDeviceMaintenance3Properties_self(dec, (VkPhysicalDeviceMaintenance3Properties *)pnext);
15398         break;
15399     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
15400         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15401         vn_decode_VkPhysicalDeviceMaintenance4Properties_self(dec, (VkPhysicalDeviceMaintenance4Properties *)pnext);
15402         break;
15403     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
15404         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15405         vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
15406         break;
15407     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
15408         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15409         vn_decode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self(dec, (VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
15410         break;
15411     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
15412         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15413         vn_decode_VkPhysicalDeviceDescriptorIndexingProperties_self(dec, (VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
15414         break;
15415     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
15416         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15417         vn_decode_VkPhysicalDeviceTimelineSemaphoreProperties_self(dec, (VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
15418         break;
15419     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
15420         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15421         vn_decode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self(dec, (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
15422         break;
15423     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
15424         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15425         vn_decode_VkPhysicalDeviceDepthStencilResolveProperties_self(dec, (VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
15426         break;
15427     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
15428         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15429         vn_decode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self(dec, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
15430         break;
15431     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
15432         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15433         vn_decode_VkPhysicalDeviceTexelBufferAlignmentProperties_self(dec, (VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
15434         break;
15435     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
15436         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15437         vn_decode_VkPhysicalDeviceSubgroupSizeControlProperties_self(dec, (VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
15438         break;
15439     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
15440         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15441         vn_decode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self(dec, (VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
15442         break;
15443     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
15444         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15445         vn_decode_VkPhysicalDeviceVulkan11Properties_self(dec, (VkPhysicalDeviceVulkan11Properties *)pnext);
15446         break;
15447     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
15448         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15449         vn_decode_VkPhysicalDeviceVulkan12Properties_self(dec, (VkPhysicalDeviceVulkan12Properties *)pnext);
15450         break;
15451     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
15452         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15453         vn_decode_VkPhysicalDeviceVulkan13Properties_self(dec, (VkPhysicalDeviceVulkan13Properties *)pnext);
15454         break;
15455     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
15456         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15457         vn_decode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self(dec, (VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
15458         break;
15459     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
15460         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15461         vn_decode_VkPhysicalDeviceRobustness2PropertiesEXT_self(dec, (VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
15462         break;
15463     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
15464         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15465         vn_decode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self(dec, (VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
15466         break;
15467     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
15468         vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
15469         vn_decode_VkPhysicalDeviceShaderIntegerDotProductProperties_self(dec, (VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
15470         break;
15471     default:
15472         assert(false);
15473         break;
15474     }
15475 }
15476 
15477 static inline void
vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)15478 vn_decode_VkPhysicalDeviceProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
15479 {
15480     /* skip val->{sType,pNext} */
15481     vn_decode_VkPhysicalDeviceProperties(dec, &val->properties);
15482 }
15483 
15484 static inline void
vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceProperties2 * val)15485 vn_decode_VkPhysicalDeviceProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceProperties2 *val)
15486 {
15487     VkStructureType stype;
15488     vn_decode_VkStructureType(dec, &stype);
15489     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
15490 
15491     assert(val->sType == stype);
15492     vn_decode_VkPhysicalDeviceProperties2_pnext(dec, val->pNext);
15493     vn_decode_VkPhysicalDeviceProperties2_self(dec, val);
15494 }
15495 
15496 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void * val)15497 vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val)
15498 {
15499     const VkBaseInStructure *pnext = val;
15500     size_t size = 0;
15501 
15502     while (pnext) {
15503         switch ((int32_t)pnext->sType) {
15504         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
15505             size += vn_sizeof_simple_pointer(pnext);
15506             size += vn_sizeof_VkStructureType(&pnext->sType);
15507             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15508             size += vn_sizeof_VkPhysicalDeviceDriverProperties_self_partial((const VkPhysicalDeviceDriverProperties *)pnext);
15509             return size;
15510         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
15511             size += vn_sizeof_simple_pointer(pnext);
15512             size += vn_sizeof_VkStructureType(&pnext->sType);
15513             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15514             size += vn_sizeof_VkPhysicalDeviceIDProperties_self_partial((const VkPhysicalDeviceIDProperties *)pnext);
15515             return size;
15516         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
15517             size += vn_sizeof_simple_pointer(pnext);
15518             size += vn_sizeof_VkStructureType(&pnext->sType);
15519             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15520             size += vn_sizeof_VkPhysicalDeviceMultiviewProperties_self_partial((const VkPhysicalDeviceMultiviewProperties *)pnext);
15521             return size;
15522         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
15523             size += vn_sizeof_simple_pointer(pnext);
15524             size += vn_sizeof_VkStructureType(&pnext->sType);
15525             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15526             size += vn_sizeof_VkPhysicalDeviceSubgroupProperties_self_partial((const VkPhysicalDeviceSubgroupProperties *)pnext);
15527             return size;
15528         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
15529             size += vn_sizeof_simple_pointer(pnext);
15530             size += vn_sizeof_VkStructureType(&pnext->sType);
15531             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15532             size += vn_sizeof_VkPhysicalDevicePointClippingProperties_self_partial((const VkPhysicalDevicePointClippingProperties *)pnext);
15533             return size;
15534         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
15535             size += vn_sizeof_simple_pointer(pnext);
15536             size += vn_sizeof_VkStructureType(&pnext->sType);
15537             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15538             size += vn_sizeof_VkPhysicalDeviceProtectedMemoryProperties_self_partial((const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
15539             return size;
15540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
15541             size += vn_sizeof_simple_pointer(pnext);
15542             size += vn_sizeof_VkStructureType(&pnext->sType);
15543             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15544             size += vn_sizeof_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial((const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
15545             return size;
15546         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
15547             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
15548                 break;
15549             size += vn_sizeof_simple_pointer(pnext);
15550             size += vn_sizeof_VkStructureType(&pnext->sType);
15551             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15552             size += vn_sizeof_VkPhysicalDeviceInlineUniformBlockProperties_self_partial((const VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
15553             return size;
15554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
15555             size += vn_sizeof_simple_pointer(pnext);
15556             size += vn_sizeof_VkStructureType(&pnext->sType);
15557             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15558             size += vn_sizeof_VkPhysicalDeviceMaintenance3Properties_self_partial((const VkPhysicalDeviceMaintenance3Properties *)pnext);
15559             return size;
15560         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
15561             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
15562                 break;
15563             size += vn_sizeof_simple_pointer(pnext);
15564             size += vn_sizeof_VkStructureType(&pnext->sType);
15565             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15566             size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial((const VkPhysicalDeviceMaintenance4Properties *)pnext);
15567             return size;
15568         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
15569             size += vn_sizeof_simple_pointer(pnext);
15570             size += vn_sizeof_VkStructureType(&pnext->sType);
15571             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15572             size += vn_sizeof_VkPhysicalDeviceFloatControlsProperties_self_partial((const VkPhysicalDeviceFloatControlsProperties *)pnext);
15573             return size;
15574         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
15575             if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
15576                 break;
15577             size += vn_sizeof_simple_pointer(pnext);
15578             size += vn_sizeof_VkStructureType(&pnext->sType);
15579             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15580             size += vn_sizeof_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial((const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
15581             return size;
15582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
15583             size += vn_sizeof_simple_pointer(pnext);
15584             size += vn_sizeof_VkStructureType(&pnext->sType);
15585             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15586             size += vn_sizeof_VkPhysicalDeviceDescriptorIndexingProperties_self_partial((const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
15587             return size;
15588         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
15589             size += vn_sizeof_simple_pointer(pnext);
15590             size += vn_sizeof_VkStructureType(&pnext->sType);
15591             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15592             size += vn_sizeof_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial((const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
15593             return size;
15594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
15595             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
15596                 break;
15597             size += vn_sizeof_simple_pointer(pnext);
15598             size += vn_sizeof_VkStructureType(&pnext->sType);
15599             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15600             size += vn_sizeof_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial((const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
15601             return size;
15602         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
15603             size += vn_sizeof_simple_pointer(pnext);
15604             size += vn_sizeof_VkStructureType(&pnext->sType);
15605             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15606             size += vn_sizeof_VkPhysicalDeviceDepthStencilResolveProperties_self_partial((const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
15607             return size;
15608         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
15609             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
15610                 break;
15611             size += vn_sizeof_simple_pointer(pnext);
15612             size += vn_sizeof_VkStructureType(&pnext->sType);
15613             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15614             size += vn_sizeof_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial((const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
15615             return size;
15616         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
15617             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
15618                 break;
15619             size += vn_sizeof_simple_pointer(pnext);
15620             size += vn_sizeof_VkStructureType(&pnext->sType);
15621             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15622             size += vn_sizeof_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial((const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
15623             return size;
15624         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
15625             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
15626                 break;
15627             size += vn_sizeof_simple_pointer(pnext);
15628             size += vn_sizeof_VkStructureType(&pnext->sType);
15629             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15630             size += vn_sizeof_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial((const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
15631             return size;
15632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
15633             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
15634                 break;
15635             size += vn_sizeof_simple_pointer(pnext);
15636             size += vn_sizeof_VkStructureType(&pnext->sType);
15637             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15638             size += vn_sizeof_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial((const VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
15639             return size;
15640         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
15641             size += vn_sizeof_simple_pointer(pnext);
15642             size += vn_sizeof_VkStructureType(&pnext->sType);
15643             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15644             size += vn_sizeof_VkPhysicalDeviceVulkan11Properties_self_partial((const VkPhysicalDeviceVulkan11Properties *)pnext);
15645             return size;
15646         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
15647             size += vn_sizeof_simple_pointer(pnext);
15648             size += vn_sizeof_VkStructureType(&pnext->sType);
15649             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15650             size += vn_sizeof_VkPhysicalDeviceVulkan12Properties_self_partial((const VkPhysicalDeviceVulkan12Properties *)pnext);
15651             return size;
15652         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
15653             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
15654                 break;
15655             size += vn_sizeof_simple_pointer(pnext);
15656             size += vn_sizeof_VkStructureType(&pnext->sType);
15657             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15658             size += vn_sizeof_VkPhysicalDeviceVulkan13Properties_self_partial((const VkPhysicalDeviceVulkan13Properties *)pnext);
15659             return size;
15660         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
15661             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
15662                 break;
15663             size += vn_sizeof_simple_pointer(pnext);
15664             size += vn_sizeof_VkStructureType(&pnext->sType);
15665             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15666             size += vn_sizeof_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial((const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
15667             return size;
15668         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
15669             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
15670                 break;
15671             size += vn_sizeof_simple_pointer(pnext);
15672             size += vn_sizeof_VkStructureType(&pnext->sType);
15673             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15674             size += vn_sizeof_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial((const VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
15675             return size;
15676         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
15677             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
15678                 break;
15679             size += vn_sizeof_simple_pointer(pnext);
15680             size += vn_sizeof_VkStructureType(&pnext->sType);
15681             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15682             size += vn_sizeof_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial((const VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
15683             return size;
15684         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
15685             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
15686                 break;
15687             size += vn_sizeof_simple_pointer(pnext);
15688             size += vn_sizeof_VkStructureType(&pnext->sType);
15689             size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
15690             size += vn_sizeof_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial((const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
15691             return size;
15692         default:
15693             /* ignore unknown/unsupported struct */
15694             break;
15695         }
15696         pnext = pnext->pNext;
15697     }
15698 
15699     return vn_sizeof_simple_pointer(NULL);
15700 }
15701 
15702 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 * val)15703 vn_sizeof_VkPhysicalDeviceProperties2_self_partial(const VkPhysicalDeviceProperties2 *val)
15704 {
15705     size_t size = 0;
15706     /* skip val->{sType,pNext} */
15707     size += vn_sizeof_VkPhysicalDeviceProperties_partial(&val->properties);
15708     return size;
15709 }
15710 
15711 static inline size_t
vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 * val)15712 vn_sizeof_VkPhysicalDeviceProperties2_partial(const VkPhysicalDeviceProperties2 *val)
15713 {
15714     size_t size = 0;
15715 
15716     size += vn_sizeof_VkStructureType(&val->sType);
15717     size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(val->pNext);
15718     size += vn_sizeof_VkPhysicalDeviceProperties2_self_partial(val);
15719 
15720     return size;
15721 }
15722 
15723 static inline void
vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)15724 vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
15725 {
15726     const VkBaseInStructure *pnext = val;
15727 
15728     while (pnext) {
15729         switch ((int32_t)pnext->sType) {
15730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
15731             vn_encode_simple_pointer(enc, pnext);
15732             vn_encode_VkStructureType(enc, &pnext->sType);
15733             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15734             vn_encode_VkPhysicalDeviceDriverProperties_self_partial(enc, (const VkPhysicalDeviceDriverProperties *)pnext);
15735             return;
15736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
15737             vn_encode_simple_pointer(enc, pnext);
15738             vn_encode_VkStructureType(enc, &pnext->sType);
15739             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15740             vn_encode_VkPhysicalDeviceIDProperties_self_partial(enc, (const VkPhysicalDeviceIDProperties *)pnext);
15741             return;
15742         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
15743             vn_encode_simple_pointer(enc, pnext);
15744             vn_encode_VkStructureType(enc, &pnext->sType);
15745             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15746             vn_encode_VkPhysicalDeviceMultiviewProperties_self_partial(enc, (const VkPhysicalDeviceMultiviewProperties *)pnext);
15747             return;
15748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
15749             vn_encode_simple_pointer(enc, pnext);
15750             vn_encode_VkStructureType(enc, &pnext->sType);
15751             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15752             vn_encode_VkPhysicalDeviceSubgroupProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupProperties *)pnext);
15753             return;
15754         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
15755             vn_encode_simple_pointer(enc, pnext);
15756             vn_encode_VkStructureType(enc, &pnext->sType);
15757             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15758             vn_encode_VkPhysicalDevicePointClippingProperties_self_partial(enc, (const VkPhysicalDevicePointClippingProperties *)pnext);
15759             return;
15760         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
15761             vn_encode_simple_pointer(enc, pnext);
15762             vn_encode_VkStructureType(enc, &pnext->sType);
15763             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15764             vn_encode_VkPhysicalDeviceProtectedMemoryProperties_self_partial(enc, (const VkPhysicalDeviceProtectedMemoryProperties *)pnext);
15765             return;
15766         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
15767             vn_encode_simple_pointer(enc, pnext);
15768             vn_encode_VkStructureType(enc, &pnext->sType);
15769             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15770             vn_encode_VkPhysicalDeviceSamplerFilterMinmaxProperties_self_partial(enc, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)pnext);
15771             return;
15772         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
15773             if (!vn_cs_renderer_protocol_has_extension(139 /* VK_EXT_inline_uniform_block */))
15774                 break;
15775             vn_encode_simple_pointer(enc, pnext);
15776             vn_encode_VkStructureType(enc, &pnext->sType);
15777             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15778             vn_encode_VkPhysicalDeviceInlineUniformBlockProperties_self_partial(enc, (const VkPhysicalDeviceInlineUniformBlockProperties *)pnext);
15779             return;
15780         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
15781             vn_encode_simple_pointer(enc, pnext);
15782             vn_encode_VkStructureType(enc, &pnext->sType);
15783             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15784             vn_encode_VkPhysicalDeviceMaintenance3Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance3Properties *)pnext);
15785             return;
15786         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
15787             if (!vn_cs_renderer_protocol_has_extension(414 /* VK_KHR_maintenance4 */))
15788                 break;
15789             vn_encode_simple_pointer(enc, pnext);
15790             vn_encode_VkStructureType(enc, &pnext->sType);
15791             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15792             vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance4Properties *)pnext);
15793             return;
15794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
15795             vn_encode_simple_pointer(enc, pnext);
15796             vn_encode_VkStructureType(enc, &pnext->sType);
15797             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15798             vn_encode_VkPhysicalDeviceFloatControlsProperties_self_partial(enc, (const VkPhysicalDeviceFloatControlsProperties *)pnext);
15799             return;
15800         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
15801             if (!vn_cs_renderer_protocol_has_extension(102 /* VK_EXT_conservative_rasterization */))
15802                 break;
15803             vn_encode_simple_pointer(enc, pnext);
15804             vn_encode_VkStructureType(enc, &pnext->sType);
15805             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15806             vn_encode_VkPhysicalDeviceConservativeRasterizationPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)pnext);
15807             return;
15808         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
15809             vn_encode_simple_pointer(enc, pnext);
15810             vn_encode_VkStructureType(enc, &pnext->sType);
15811             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15812             vn_encode_VkPhysicalDeviceDescriptorIndexingProperties_self_partial(enc, (const VkPhysicalDeviceDescriptorIndexingProperties *)pnext);
15813             return;
15814         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
15815             vn_encode_simple_pointer(enc, pnext);
15816             vn_encode_VkStructureType(enc, &pnext->sType);
15817             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15818             vn_encode_VkPhysicalDeviceTimelineSemaphoreProperties_self_partial(enc, (const VkPhysicalDeviceTimelineSemaphoreProperties *)pnext);
15819             return;
15820         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
15821             if (!vn_cs_renderer_protocol_has_extension(191 /* VK_EXT_vertex_attribute_divisor */))
15822                 break;
15823             vn_encode_simple_pointer(enc, pnext);
15824             vn_encode_VkStructureType(enc, &pnext->sType);
15825             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15826             vn_encode_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)pnext);
15827             return;
15828         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
15829             vn_encode_simple_pointer(enc, pnext);
15830             vn_encode_VkStructureType(enc, &pnext->sType);
15831             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15832             vn_encode_VkPhysicalDeviceDepthStencilResolveProperties_self_partial(enc, (const VkPhysicalDeviceDepthStencilResolveProperties *)pnext);
15833             return;
15834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
15835             if (!vn_cs_renderer_protocol_has_extension(29 /* VK_EXT_transform_feedback */))
15836                 break;
15837             vn_encode_simple_pointer(enc, pnext);
15838             vn_encode_VkStructureType(enc, &pnext->sType);
15839             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15840             vn_encode_VkPhysicalDeviceTransformFeedbackPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)pnext);
15841             return;
15842         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
15843             if (!vn_cs_renderer_protocol_has_extension(282 /* VK_EXT_texel_buffer_alignment */))
15844                 break;
15845             vn_encode_simple_pointer(enc, pnext);
15846             vn_encode_VkStructureType(enc, &pnext->sType);
15847             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15848             vn_encode_VkPhysicalDeviceTexelBufferAlignmentProperties_self_partial(enc, (const VkPhysicalDeviceTexelBufferAlignmentProperties *)pnext);
15849             return;
15850         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
15851             if (!vn_cs_renderer_protocol_has_extension(226 /* VK_EXT_subgroup_size_control */))
15852                 break;
15853             vn_encode_simple_pointer(enc, pnext);
15854             vn_encode_VkStructureType(enc, &pnext->sType);
15855             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15856             vn_encode_VkPhysicalDeviceSubgroupSizeControlProperties_self_partial(enc, (const VkPhysicalDeviceSubgroupSizeControlProperties *)pnext);
15857             return;
15858         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
15859             if (!vn_cs_renderer_protocol_has_extension(260 /* VK_EXT_line_rasterization */))
15860                 break;
15861             vn_encode_simple_pointer(enc, pnext);
15862             vn_encode_VkStructureType(enc, &pnext->sType);
15863             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15864             vn_encode_VkPhysicalDeviceLineRasterizationPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)pnext);
15865             return;
15866         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
15867             vn_encode_simple_pointer(enc, pnext);
15868             vn_encode_VkStructureType(enc, &pnext->sType);
15869             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15870             vn_encode_VkPhysicalDeviceVulkan11Properties_self_partial(enc, (const VkPhysicalDeviceVulkan11Properties *)pnext);
15871             return;
15872         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
15873             vn_encode_simple_pointer(enc, pnext);
15874             vn_encode_VkStructureType(enc, &pnext->sType);
15875             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15876             vn_encode_VkPhysicalDeviceVulkan12Properties_self_partial(enc, (const VkPhysicalDeviceVulkan12Properties *)pnext);
15877             return;
15878         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
15879             if (!vn_cs_renderer_protocol_has_api_version(VK_API_VERSION_1_3))
15880                 break;
15881             vn_encode_simple_pointer(enc, pnext);
15882             vn_encode_VkStructureType(enc, &pnext->sType);
15883             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15884             vn_encode_VkPhysicalDeviceVulkan13Properties_self_partial(enc, (const VkPhysicalDeviceVulkan13Properties *)pnext);
15885             return;
15886         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
15887             if (!vn_cs_renderer_protocol_has_extension(288 /* VK_EXT_custom_border_color */))
15888                 break;
15889             vn_encode_simple_pointer(enc, pnext);
15890             vn_encode_VkStructureType(enc, &pnext->sType);
15891             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15892             vn_encode_VkPhysicalDeviceCustomBorderColorPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)pnext);
15893             return;
15894         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
15895             if (!vn_cs_renderer_protocol_has_extension(287 /* VK_EXT_robustness2 */))
15896                 break;
15897             vn_encode_simple_pointer(enc, pnext);
15898             vn_encode_VkStructureType(enc, &pnext->sType);
15899             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15900             vn_encode_VkPhysicalDeviceRobustness2PropertiesEXT_self_partial(enc, (const VkPhysicalDeviceRobustness2PropertiesEXT *)pnext);
15901             return;
15902         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
15903             if (!vn_cs_renderer_protocol_has_extension(255 /* VK_EXT_provoking_vertex */))
15904                 break;
15905             vn_encode_simple_pointer(enc, pnext);
15906             vn_encode_VkStructureType(enc, &pnext->sType);
15907             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15908             vn_encode_VkPhysicalDeviceProvokingVertexPropertiesEXT_self_partial(enc, (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)pnext);
15909             return;
15910         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
15911             if (!vn_cs_renderer_protocol_has_extension(281 /* VK_KHR_shader_integer_dot_product */))
15912                 break;
15913             vn_encode_simple_pointer(enc, pnext);
15914             vn_encode_VkStructureType(enc, &pnext->sType);
15915             vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
15916             vn_encode_VkPhysicalDeviceShaderIntegerDotProductProperties_self_partial(enc, (const VkPhysicalDeviceShaderIntegerDotProductProperties *)pnext);
15917             return;
15918         default:
15919             /* ignore unknown/unsupported struct */
15920             break;
15921         }
15922         pnext = pnext->pNext;
15923     }
15924 
15925     vn_encode_simple_pointer(enc, NULL);
15926 }
15927 
15928 static inline void
vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)15929 vn_encode_VkPhysicalDeviceProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
15930 {
15931     /* skip val->{sType,pNext} */
15932     vn_encode_VkPhysicalDeviceProperties_partial(enc, &val->properties);
15933 }
15934 
15935 static inline void
vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceProperties2 * val)15936 vn_encode_VkPhysicalDeviceProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceProperties2 *val)
15937 {
15938     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
15939     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 });
15940     vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, val->pNext);
15941     vn_encode_VkPhysicalDeviceProperties2_self_partial(enc, val);
15942 }
15943 
15944 /* struct VkDrmFormatModifierPropertiesEXT */
15945 
15946 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT * val)15947 vn_sizeof_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT *val)
15948 {
15949     size_t size = 0;
15950     size += vn_sizeof_uint64_t(&val->drmFormatModifier);
15951     size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
15952     size += vn_sizeof_VkFlags(&val->drmFormatModifierTilingFeatures);
15953     return size;
15954 }
15955 
15956 static inline void
vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesEXT * val)15957 vn_decode_VkDrmFormatModifierPropertiesEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesEXT *val)
15958 {
15959     vn_decode_uint64_t(dec, &val->drmFormatModifier);
15960     vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
15961     vn_decode_VkFlags(dec, &val->drmFormatModifierTilingFeatures);
15962 }
15963 
15964 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT * val)15965 vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(const VkDrmFormatModifierPropertiesEXT *val)
15966 {
15967     size_t size = 0;
15968     /* skip val->drmFormatModifier */
15969     /* skip val->drmFormatModifierPlaneCount */
15970     /* skip val->drmFormatModifierTilingFeatures */
15971     return size;
15972 }
15973 
15974 static inline void
vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesEXT * val)15975 vn_encode_VkDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesEXT *val)
15976 {
15977     /* skip val->drmFormatModifier */
15978     /* skip val->drmFormatModifierPlaneCount */
15979     /* skip val->drmFormatModifierTilingFeatures */
15980 }
15981 
15982 /* struct VkDrmFormatModifierPropertiesListEXT chain */
15983 
15984 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void * val)15985 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(const void *val)
15986 {
15987     /* no known/supported struct */
15988     return vn_sizeof_simple_pointer(NULL);
15989 }
15990 
15991 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT * val)15992 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(const VkDrmFormatModifierPropertiesListEXT *val)
15993 {
15994     size_t size = 0;
15995     /* skip val->{sType,pNext} */
15996     size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
15997     if (val->pDrmFormatModifierProperties) {
15998         size += vn_sizeof_array_size(val->drmFormatModifierCount);
15999         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
16000             size += vn_sizeof_VkDrmFormatModifierPropertiesEXT(&val->pDrmFormatModifierProperties[i]);
16001     } else {
16002         size += vn_sizeof_array_size(0);
16003     }
16004     return size;
16005 }
16006 
16007 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT * val)16008 vn_sizeof_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT *val)
16009 {
16010     size_t size = 0;
16011 
16012     size += vn_sizeof_VkStructureType(&val->sType);
16013     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext(val->pNext);
16014     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self(val);
16015 
16016     return size;
16017 }
16018 
16019 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder * dec,const void * val)16020 vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(struct vn_cs_decoder *dec, const void *val)
16021 {
16022     /* no known/supported struct */
16023     if (vn_decode_simple_pointer(dec))
16024         assert(false);
16025 }
16026 
16027 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)16028 vn_decode_VkDrmFormatModifierPropertiesListEXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
16029 {
16030     /* skip val->{sType,pNext} */
16031     vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
16032     if (vn_peek_array_size(dec)) {
16033         const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount);
16034         for (uint32_t i = 0; i < iter_count; i++)
16035             vn_decode_VkDrmFormatModifierPropertiesEXT(dec, &val->pDrmFormatModifierProperties[i]);
16036     } else {
16037         vn_decode_array_size_unchecked(dec);
16038         val->pDrmFormatModifierProperties = NULL;
16039     }
16040 }
16041 
16042 static inline void
vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesListEXT * val)16043 vn_decode_VkDrmFormatModifierPropertiesListEXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesListEXT *val)
16044 {
16045     VkStructureType stype;
16046     vn_decode_VkStructureType(dec, &stype);
16047     assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
16048 
16049     assert(val->sType == stype);
16050     vn_decode_VkDrmFormatModifierPropertiesListEXT_pnext(dec, val->pNext);
16051     vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, val);
16052 }
16053 
16054 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void * val)16055 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(const void *val)
16056 {
16057     /* no known/supported struct */
16058     return vn_sizeof_simple_pointer(NULL);
16059 }
16060 
16061 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT * val)16062 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(const VkDrmFormatModifierPropertiesListEXT *val)
16063 {
16064     size_t size = 0;
16065     /* skip val->{sType,pNext} */
16066     /* WA1: size += vn_sizeof_uint32_t(&val->drmFormatModifierCount) */(void)0;
16067     if (val->pDrmFormatModifierProperties) {
16068         size += vn_sizeof_array_size(val->drmFormatModifierCount);
16069         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
16070             size += vn_sizeof_VkDrmFormatModifierPropertiesEXT_partial(&val->pDrmFormatModifierProperties[i]);
16071     } else {
16072         size += vn_sizeof_array_size(0);
16073     }
16074     return size;
16075 }
16076 
16077 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT * val)16078 vn_sizeof_VkDrmFormatModifierPropertiesListEXT_partial(const VkDrmFormatModifierPropertiesListEXT *val)
16079 {
16080     size_t size = 0;
16081 
16082     size += vn_sizeof_VkStructureType(&val->sType);
16083     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_pnext_partial(val->pNext);
16084     size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial(val);
16085 
16086     return size;
16087 }
16088 
16089 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)16090 vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16091 {
16092     /* no known/supported struct */
16093     vn_encode_simple_pointer(enc, NULL);
16094 }
16095 
16096 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)16097 vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
16098 {
16099     /* skip val->{sType,pNext} */
16100     /* WA1: vn_encode_uint32_t(enc, &val->drmFormatModifierCount) */(void)0;
16101     if (val->pDrmFormatModifierProperties) {
16102         vn_encode_array_size(enc, val->drmFormatModifierCount);
16103         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
16104             vn_encode_VkDrmFormatModifierPropertiesEXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
16105     } else {
16106         vn_encode_array_size(enc, 0);
16107     }
16108 }
16109 
16110 static inline void
vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesListEXT * val)16111 vn_encode_VkDrmFormatModifierPropertiesListEXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesListEXT *val)
16112 {
16113     assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
16114     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT });
16115     vn_encode_VkDrmFormatModifierPropertiesListEXT_pnext_partial(enc, val->pNext);
16116     vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, val);
16117 }
16118 
16119 /* struct VkFormatProperties3 chain */
16120 
16121 static inline size_t
vn_sizeof_VkFormatProperties3_pnext(const void * val)16122 vn_sizeof_VkFormatProperties3_pnext(const void *val)
16123 {
16124     /* no known/supported struct */
16125     return vn_sizeof_simple_pointer(NULL);
16126 }
16127 
16128 static inline size_t
vn_sizeof_VkFormatProperties3_self(const VkFormatProperties3 * val)16129 vn_sizeof_VkFormatProperties3_self(const VkFormatProperties3 *val)
16130 {
16131     size_t size = 0;
16132     /* skip val->{sType,pNext} */
16133     size += vn_sizeof_VkFlags64(&val->linearTilingFeatures);
16134     size += vn_sizeof_VkFlags64(&val->optimalTilingFeatures);
16135     size += vn_sizeof_VkFlags64(&val->bufferFeatures);
16136     return size;
16137 }
16138 
16139 static inline size_t
vn_sizeof_VkFormatProperties3(const VkFormatProperties3 * val)16140 vn_sizeof_VkFormatProperties3(const VkFormatProperties3 *val)
16141 {
16142     size_t size = 0;
16143 
16144     size += vn_sizeof_VkStructureType(&val->sType);
16145     size += vn_sizeof_VkFormatProperties3_pnext(val->pNext);
16146     size += vn_sizeof_VkFormatProperties3_self(val);
16147 
16148     return size;
16149 }
16150 
16151 static inline void
vn_decode_VkFormatProperties3_pnext(struct vn_cs_decoder * dec,const void * val)16152 vn_decode_VkFormatProperties3_pnext(struct vn_cs_decoder *dec, const void *val)
16153 {
16154     /* no known/supported struct */
16155     if (vn_decode_simple_pointer(dec))
16156         assert(false);
16157 }
16158 
16159 static inline void
vn_decode_VkFormatProperties3_self(struct vn_cs_decoder * dec,VkFormatProperties3 * val)16160 vn_decode_VkFormatProperties3_self(struct vn_cs_decoder *dec, VkFormatProperties3 *val)
16161 {
16162     /* skip val->{sType,pNext} */
16163     vn_decode_VkFlags64(dec, &val->linearTilingFeatures);
16164     vn_decode_VkFlags64(dec, &val->optimalTilingFeatures);
16165     vn_decode_VkFlags64(dec, &val->bufferFeatures);
16166 }
16167 
16168 static inline void
vn_decode_VkFormatProperties3(struct vn_cs_decoder * dec,VkFormatProperties3 * val)16169 vn_decode_VkFormatProperties3(struct vn_cs_decoder *dec, VkFormatProperties3 *val)
16170 {
16171     VkStructureType stype;
16172     vn_decode_VkStructureType(dec, &stype);
16173     assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
16174 
16175     assert(val->sType == stype);
16176     vn_decode_VkFormatProperties3_pnext(dec, val->pNext);
16177     vn_decode_VkFormatProperties3_self(dec, val);
16178 }
16179 
16180 static inline size_t
vn_sizeof_VkFormatProperties3_pnext_partial(const void * val)16181 vn_sizeof_VkFormatProperties3_pnext_partial(const void *val)
16182 {
16183     /* no known/supported struct */
16184     return vn_sizeof_simple_pointer(NULL);
16185 }
16186 
16187 static inline size_t
vn_sizeof_VkFormatProperties3_self_partial(const VkFormatProperties3 * val)16188 vn_sizeof_VkFormatProperties3_self_partial(const VkFormatProperties3 *val)
16189 {
16190     size_t size = 0;
16191     /* skip val->{sType,pNext} */
16192     /* skip val->linearTilingFeatures */
16193     /* skip val->optimalTilingFeatures */
16194     /* skip val->bufferFeatures */
16195     return size;
16196 }
16197 
16198 static inline size_t
vn_sizeof_VkFormatProperties3_partial(const VkFormatProperties3 * val)16199 vn_sizeof_VkFormatProperties3_partial(const VkFormatProperties3 *val)
16200 {
16201     size_t size = 0;
16202 
16203     size += vn_sizeof_VkStructureType(&val->sType);
16204     size += vn_sizeof_VkFormatProperties3_pnext_partial(val->pNext);
16205     size += vn_sizeof_VkFormatProperties3_self_partial(val);
16206 
16207     return size;
16208 }
16209 
16210 static inline void
vn_encode_VkFormatProperties3_pnext_partial(struct vn_cs_encoder * enc,const void * val)16211 vn_encode_VkFormatProperties3_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16212 {
16213     /* no known/supported struct */
16214     vn_encode_simple_pointer(enc, NULL);
16215 }
16216 
16217 static inline void
vn_encode_VkFormatProperties3_self_partial(struct vn_cs_encoder * enc,const VkFormatProperties3 * val)16218 vn_encode_VkFormatProperties3_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties3 *val)
16219 {
16220     /* skip val->{sType,pNext} */
16221     /* skip val->linearTilingFeatures */
16222     /* skip val->optimalTilingFeatures */
16223     /* skip val->bufferFeatures */
16224 }
16225 
16226 static inline void
vn_encode_VkFormatProperties3_partial(struct vn_cs_encoder * enc,const VkFormatProperties3 * val)16227 vn_encode_VkFormatProperties3_partial(struct vn_cs_encoder *enc, const VkFormatProperties3 *val)
16228 {
16229     assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
16230     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 });
16231     vn_encode_VkFormatProperties3_pnext_partial(enc, val->pNext);
16232     vn_encode_VkFormatProperties3_self_partial(enc, val);
16233 }
16234 
16235 /* struct VkDrmFormatModifierProperties2EXT */
16236 
16237 static inline size_t
vn_sizeof_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT * val)16238 vn_sizeof_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT *val)
16239 {
16240     size_t size = 0;
16241     size += vn_sizeof_uint64_t(&val->drmFormatModifier);
16242     size += vn_sizeof_uint32_t(&val->drmFormatModifierPlaneCount);
16243     size += vn_sizeof_VkFlags64(&val->drmFormatModifierTilingFeatures);
16244     return size;
16245 }
16246 
16247 static inline void
vn_decode_VkDrmFormatModifierProperties2EXT(struct vn_cs_decoder * dec,VkDrmFormatModifierProperties2EXT * val)16248 vn_decode_VkDrmFormatModifierProperties2EXT(struct vn_cs_decoder *dec, VkDrmFormatModifierProperties2EXT *val)
16249 {
16250     vn_decode_uint64_t(dec, &val->drmFormatModifier);
16251     vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
16252     vn_decode_VkFlags64(dec, &val->drmFormatModifierTilingFeatures);
16253 }
16254 
16255 static inline size_t
vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(const VkDrmFormatModifierProperties2EXT * val)16256 vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(const VkDrmFormatModifierProperties2EXT *val)
16257 {
16258     size_t size = 0;
16259     /* skip val->drmFormatModifier */
16260     /* skip val->drmFormatModifierPlaneCount */
16261     /* skip val->drmFormatModifierTilingFeatures */
16262     return size;
16263 }
16264 
16265 static inline void
vn_encode_VkDrmFormatModifierProperties2EXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierProperties2EXT * val)16266 vn_encode_VkDrmFormatModifierProperties2EXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierProperties2EXT *val)
16267 {
16268     /* skip val->drmFormatModifier */
16269     /* skip val->drmFormatModifierPlaneCount */
16270     /* skip val->drmFormatModifierTilingFeatures */
16271 }
16272 
16273 /* struct VkDrmFormatModifierPropertiesList2EXT chain */
16274 
16275 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(const void * val)16276 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(const void *val)
16277 {
16278     /* no known/supported struct */
16279     return vn_sizeof_simple_pointer(NULL);
16280 }
16281 
16282 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(const VkDrmFormatModifierPropertiesList2EXT * val)16283 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(const VkDrmFormatModifierPropertiesList2EXT *val)
16284 {
16285     size_t size = 0;
16286     /* skip val->{sType,pNext} */
16287     size += vn_sizeof_uint32_t(&val->drmFormatModifierCount);
16288     if (val->pDrmFormatModifierProperties) {
16289         size += vn_sizeof_array_size(val->drmFormatModifierCount);
16290         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
16291             size += vn_sizeof_VkDrmFormatModifierProperties2EXT(&val->pDrmFormatModifierProperties[i]);
16292     } else {
16293         size += vn_sizeof_array_size(0);
16294     }
16295     return size;
16296 }
16297 
16298 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT * val)16299 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT *val)
16300 {
16301     size_t size = 0;
16302 
16303     size += vn_sizeof_VkStructureType(&val->sType);
16304     size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext(val->pNext);
16305     size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self(val);
16306 
16307     return size;
16308 }
16309 
16310 static inline void
vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(struct vn_cs_decoder * dec,const void * val)16311 vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(struct vn_cs_decoder *dec, const void *val)
16312 {
16313     /* no known/supported struct */
16314     if (vn_decode_simple_pointer(dec))
16315         assert(false);
16316 }
16317 
16318 static inline void
vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesList2EXT * val)16319 vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesList2EXT *val)
16320 {
16321     /* skip val->{sType,pNext} */
16322     vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
16323     if (vn_peek_array_size(dec)) {
16324         const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierCount);
16325         for (uint32_t i = 0; i < iter_count; i++)
16326             vn_decode_VkDrmFormatModifierProperties2EXT(dec, &val->pDrmFormatModifierProperties[i]);
16327     } else {
16328         vn_decode_array_size_unchecked(dec);
16329         val->pDrmFormatModifierProperties = NULL;
16330     }
16331 }
16332 
16333 static inline void
vn_decode_VkDrmFormatModifierPropertiesList2EXT(struct vn_cs_decoder * dec,VkDrmFormatModifierPropertiesList2EXT * val)16334 vn_decode_VkDrmFormatModifierPropertiesList2EXT(struct vn_cs_decoder *dec, VkDrmFormatModifierPropertiesList2EXT *val)
16335 {
16336     VkStructureType stype;
16337     vn_decode_VkStructureType(dec, &stype);
16338     assert(stype == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT);
16339 
16340     assert(val->sType == stype);
16341     vn_decode_VkDrmFormatModifierPropertiesList2EXT_pnext(dec, val->pNext);
16342     vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(dec, val);
16343 }
16344 
16345 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(const void * val)16346 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(const void *val)
16347 {
16348     /* no known/supported struct */
16349     return vn_sizeof_simple_pointer(NULL);
16350 }
16351 
16352 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(const VkDrmFormatModifierPropertiesList2EXT * val)16353 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(const VkDrmFormatModifierPropertiesList2EXT *val)
16354 {
16355     size_t size = 0;
16356     /* skip val->{sType,pNext} */
16357     /* WA1: size += vn_sizeof_uint32_t(&val->drmFormatModifierCount) */(void)0;
16358     if (val->pDrmFormatModifierProperties) {
16359         size += vn_sizeof_array_size(val->drmFormatModifierCount);
16360         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
16361             size += vn_sizeof_VkDrmFormatModifierProperties2EXT_partial(&val->pDrmFormatModifierProperties[i]);
16362     } else {
16363         size += vn_sizeof_array_size(0);
16364     }
16365     return size;
16366 }
16367 
16368 static inline size_t
vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_partial(const VkDrmFormatModifierPropertiesList2EXT * val)16369 vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_partial(const VkDrmFormatModifierPropertiesList2EXT *val)
16370 {
16371     size_t size = 0;
16372 
16373     size += vn_sizeof_VkStructureType(&val->sType);
16374     size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(val->pNext);
16375     size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial(val);
16376 
16377     return size;
16378 }
16379 
16380 static inline void
vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(struct vn_cs_encoder * enc,const void * val)16381 vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16382 {
16383     /* no known/supported struct */
16384     vn_encode_simple_pointer(enc, NULL);
16385 }
16386 
16387 static inline void
vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesList2EXT * val)16388 vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesList2EXT *val)
16389 {
16390     /* skip val->{sType,pNext} */
16391     /* WA1: vn_encode_uint32_t(enc, &val->drmFormatModifierCount) */(void)0;
16392     if (val->pDrmFormatModifierProperties) {
16393         vn_encode_array_size(enc, val->drmFormatModifierCount);
16394         for (uint32_t i = 0; i < val->drmFormatModifierCount; i++)
16395             vn_encode_VkDrmFormatModifierProperties2EXT_partial(enc, &val->pDrmFormatModifierProperties[i]);
16396     } else {
16397         vn_encode_array_size(enc, 0);
16398     }
16399 }
16400 
16401 static inline void
vn_encode_VkDrmFormatModifierPropertiesList2EXT_partial(struct vn_cs_encoder * enc,const VkDrmFormatModifierPropertiesList2EXT * val)16402 vn_encode_VkDrmFormatModifierPropertiesList2EXT_partial(struct vn_cs_encoder *enc, const VkDrmFormatModifierPropertiesList2EXT *val)
16403 {
16404     assert(val->sType == VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT);
16405     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT });
16406     vn_encode_VkDrmFormatModifierPropertiesList2EXT_pnext_partial(enc, val->pNext);
16407     vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(enc, val);
16408 }
16409 
16410 /* struct VkFormatProperties2 chain */
16411 
16412 static inline size_t
vn_sizeof_VkFormatProperties2_pnext(const void * val)16413 vn_sizeof_VkFormatProperties2_pnext(const void *val)
16414 {
16415     const VkBaseInStructure *pnext = val;
16416     size_t size = 0;
16417 
16418     while (pnext) {
16419         switch ((int32_t)pnext->sType) {
16420         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
16421             if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
16422                 break;
16423             size += vn_sizeof_simple_pointer(pnext);
16424             size += vn_sizeof_VkStructureType(&pnext->sType);
16425             size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
16426             size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self((const VkDrmFormatModifierPropertiesListEXT *)pnext);
16427             return size;
16428         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
16429             if (!vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */))
16430                 break;
16431             size += vn_sizeof_simple_pointer(pnext);
16432             size += vn_sizeof_VkStructureType(&pnext->sType);
16433             size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
16434             size += vn_sizeof_VkFormatProperties3_self((const VkFormatProperties3 *)pnext);
16435             return size;
16436         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
16437             if (!(vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */) && vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */)))
16438                 break;
16439             size += vn_sizeof_simple_pointer(pnext);
16440             size += vn_sizeof_VkStructureType(&pnext->sType);
16441             size += vn_sizeof_VkFormatProperties2_pnext(pnext->pNext);
16442             size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self((const VkDrmFormatModifierPropertiesList2EXT *)pnext);
16443             return size;
16444         default:
16445             /* ignore unknown/unsupported struct */
16446             break;
16447         }
16448         pnext = pnext->pNext;
16449     }
16450 
16451     return vn_sizeof_simple_pointer(NULL);
16452 }
16453 
16454 static inline size_t
vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 * val)16455 vn_sizeof_VkFormatProperties2_self(const VkFormatProperties2 *val)
16456 {
16457     size_t size = 0;
16458     /* skip val->{sType,pNext} */
16459     size += vn_sizeof_VkFormatProperties(&val->formatProperties);
16460     return size;
16461 }
16462 
16463 static inline size_t
vn_sizeof_VkFormatProperties2(const VkFormatProperties2 * val)16464 vn_sizeof_VkFormatProperties2(const VkFormatProperties2 *val)
16465 {
16466     size_t size = 0;
16467 
16468     size += vn_sizeof_VkStructureType(&val->sType);
16469     size += vn_sizeof_VkFormatProperties2_pnext(val->pNext);
16470     size += vn_sizeof_VkFormatProperties2_self(val);
16471 
16472     return size;
16473 }
16474 
16475 static inline void
vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)16476 vn_decode_VkFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
16477 {
16478     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
16479     VkStructureType stype;
16480 
16481     if (!vn_decode_simple_pointer(dec))
16482         return;
16483 
16484     vn_decode_VkStructureType(dec, &stype);
16485     while (true) {
16486         assert(pnext);
16487         if (pnext->sType == stype)
16488             break;
16489 
16490         pnext = pnext->pNext;
16491     }
16492 
16493     switch ((int32_t)pnext->sType) {
16494     case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
16495         vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
16496         vn_decode_VkDrmFormatModifierPropertiesListEXT_self(dec, (VkDrmFormatModifierPropertiesListEXT *)pnext);
16497         break;
16498     case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
16499         vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
16500         vn_decode_VkFormatProperties3_self(dec, (VkFormatProperties3 *)pnext);
16501         break;
16502     case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
16503         vn_decode_VkFormatProperties2_pnext(dec, pnext->pNext);
16504         vn_decode_VkDrmFormatModifierPropertiesList2EXT_self(dec, (VkDrmFormatModifierPropertiesList2EXT *)pnext);
16505         break;
16506     default:
16507         assert(false);
16508         break;
16509     }
16510 }
16511 
16512 static inline void
vn_decode_VkFormatProperties2_self(struct vn_cs_decoder * dec,VkFormatProperties2 * val)16513 vn_decode_VkFormatProperties2_self(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
16514 {
16515     /* skip val->{sType,pNext} */
16516     vn_decode_VkFormatProperties(dec, &val->formatProperties);
16517 }
16518 
16519 static inline void
vn_decode_VkFormatProperties2(struct vn_cs_decoder * dec,VkFormatProperties2 * val)16520 vn_decode_VkFormatProperties2(struct vn_cs_decoder *dec, VkFormatProperties2 *val)
16521 {
16522     VkStructureType stype;
16523     vn_decode_VkStructureType(dec, &stype);
16524     assert(stype == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
16525 
16526     assert(val->sType == stype);
16527     vn_decode_VkFormatProperties2_pnext(dec, val->pNext);
16528     vn_decode_VkFormatProperties2_self(dec, val);
16529 }
16530 
16531 static inline size_t
vn_sizeof_VkFormatProperties2_pnext_partial(const void * val)16532 vn_sizeof_VkFormatProperties2_pnext_partial(const void *val)
16533 {
16534     const VkBaseInStructure *pnext = val;
16535     size_t size = 0;
16536 
16537     while (pnext) {
16538         switch ((int32_t)pnext->sType) {
16539         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
16540             if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
16541                 break;
16542             size += vn_sizeof_simple_pointer(pnext);
16543             size += vn_sizeof_VkStructureType(&pnext->sType);
16544             size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
16545             size += vn_sizeof_VkDrmFormatModifierPropertiesListEXT_self_partial((const VkDrmFormatModifierPropertiesListEXT *)pnext);
16546             return size;
16547         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
16548             if (!vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */))
16549                 break;
16550             size += vn_sizeof_simple_pointer(pnext);
16551             size += vn_sizeof_VkStructureType(&pnext->sType);
16552             size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
16553             size += vn_sizeof_VkFormatProperties3_self_partial((const VkFormatProperties3 *)pnext);
16554             return size;
16555         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
16556             if (!(vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */) && vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */)))
16557                 break;
16558             size += vn_sizeof_simple_pointer(pnext);
16559             size += vn_sizeof_VkStructureType(&pnext->sType);
16560             size += vn_sizeof_VkFormatProperties2_pnext_partial(pnext->pNext);
16561             size += vn_sizeof_VkDrmFormatModifierPropertiesList2EXT_self_partial((const VkDrmFormatModifierPropertiesList2EXT *)pnext);
16562             return size;
16563         default:
16564             /* ignore unknown/unsupported struct */
16565             break;
16566         }
16567         pnext = pnext->pNext;
16568     }
16569 
16570     return vn_sizeof_simple_pointer(NULL);
16571 }
16572 
16573 static inline size_t
vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 * val)16574 vn_sizeof_VkFormatProperties2_self_partial(const VkFormatProperties2 *val)
16575 {
16576     size_t size = 0;
16577     /* skip val->{sType,pNext} */
16578     size += vn_sizeof_VkFormatProperties_partial(&val->formatProperties);
16579     return size;
16580 }
16581 
16582 static inline size_t
vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 * val)16583 vn_sizeof_VkFormatProperties2_partial(const VkFormatProperties2 *val)
16584 {
16585     size_t size = 0;
16586 
16587     size += vn_sizeof_VkStructureType(&val->sType);
16588     size += vn_sizeof_VkFormatProperties2_pnext_partial(val->pNext);
16589     size += vn_sizeof_VkFormatProperties2_self_partial(val);
16590 
16591     return size;
16592 }
16593 
16594 static inline void
vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)16595 vn_encode_VkFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
16596 {
16597     const VkBaseInStructure *pnext = val;
16598 
16599     while (pnext) {
16600         switch ((int32_t)pnext->sType) {
16601         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
16602             if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
16603                 break;
16604             vn_encode_simple_pointer(enc, pnext);
16605             vn_encode_VkStructureType(enc, &pnext->sType);
16606             vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
16607             vn_encode_VkDrmFormatModifierPropertiesListEXT_self_partial(enc, (const VkDrmFormatModifierPropertiesListEXT *)pnext);
16608             return;
16609         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
16610             if (!vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */))
16611                 break;
16612             vn_encode_simple_pointer(enc, pnext);
16613             vn_encode_VkStructureType(enc, &pnext->sType);
16614             vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
16615             vn_encode_VkFormatProperties3_self_partial(enc, (const VkFormatProperties3 *)pnext);
16616             return;
16617         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
16618             if (!(vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */) && vn_cs_renderer_protocol_has_extension(361 /* VK_KHR_format_feature_flags2 */)))
16619                 break;
16620             vn_encode_simple_pointer(enc, pnext);
16621             vn_encode_VkStructureType(enc, &pnext->sType);
16622             vn_encode_VkFormatProperties2_pnext_partial(enc, pnext->pNext);
16623             vn_encode_VkDrmFormatModifierPropertiesList2EXT_self_partial(enc, (const VkDrmFormatModifierPropertiesList2EXT *)pnext);
16624             return;
16625         default:
16626             /* ignore unknown/unsupported struct */
16627             break;
16628         }
16629         pnext = pnext->pNext;
16630     }
16631 
16632     vn_encode_simple_pointer(enc, NULL);
16633 }
16634 
16635 static inline void
vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)16636 vn_encode_VkFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
16637 {
16638     /* skip val->{sType,pNext} */
16639     vn_encode_VkFormatProperties_partial(enc, &val->formatProperties);
16640 }
16641 
16642 static inline void
vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder * enc,const VkFormatProperties2 * val)16643 vn_encode_VkFormatProperties2_partial(struct vn_cs_encoder *enc, const VkFormatProperties2 *val)
16644 {
16645     assert(val->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
16646     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 });
16647     vn_encode_VkFormatProperties2_pnext_partial(enc, val->pNext);
16648     vn_encode_VkFormatProperties2_self_partial(enc, val);
16649 }
16650 
16651 /* struct VkPhysicalDeviceExternalImageFormatInfo chain */
16652 
16653 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void * val)16654 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(const void *val)
16655 {
16656     /* no known/supported struct */
16657     return vn_sizeof_simple_pointer(NULL);
16658 }
16659 
16660 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo * val)16661 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(const VkPhysicalDeviceExternalImageFormatInfo *val)
16662 {
16663     size_t size = 0;
16664     /* skip val->{sType,pNext} */
16665     size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
16666     return size;
16667 }
16668 
16669 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo * val)16670 vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo *val)
16671 {
16672     size_t size = 0;
16673 
16674     size += vn_sizeof_VkStructureType(&val->sType);
16675     size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_pnext(val->pNext);
16676     size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self(val);
16677 
16678     return size;
16679 }
16680 
16681 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder * enc,const void * val)16682 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(struct vn_cs_encoder *enc, const void *val)
16683 {
16684     /* no known/supported struct */
16685     vn_encode_simple_pointer(enc, NULL);
16686 }
16687 
16688 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)16689 vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
16690 {
16691     /* skip val->{sType,pNext} */
16692     vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
16693 }
16694 
16695 static inline void
vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalImageFormatInfo * val)16696 vn_encode_VkPhysicalDeviceExternalImageFormatInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalImageFormatInfo *val)
16697 {
16698     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
16699     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO });
16700     vn_encode_VkPhysicalDeviceExternalImageFormatInfo_pnext(enc, val->pNext);
16701     vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, val);
16702 }
16703 
16704 /* struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT chain */
16705 
16706 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void * val)16707 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(const void *val)
16708 {
16709     /* no known/supported struct */
16710     return vn_sizeof_simple_pointer(NULL);
16711 }
16712 
16713 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)16714 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
16715 {
16716     size_t size = 0;
16717     /* skip val->{sType,pNext} */
16718     size += vn_sizeof_uint64_t(&val->drmFormatModifier);
16719     size += vn_sizeof_VkSharingMode(&val->sharingMode);
16720     size += vn_sizeof_uint32_t(&val->queueFamilyIndexCount);
16721     if (val->pQueueFamilyIndices) {
16722         size += vn_sizeof_array_size(val->queueFamilyIndexCount);
16723         size += vn_sizeof_uint32_t_array(val->pQueueFamilyIndices, val->queueFamilyIndexCount);
16724     } else {
16725         size += vn_sizeof_array_size(0);
16726     }
16727     return size;
16728 }
16729 
16730 static inline size_t
vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)16731 vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
16732 {
16733     size_t size = 0;
16734 
16735     size += vn_sizeof_VkStructureType(&val->sType);
16736     size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(val->pNext);
16737     size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(val);
16738 
16739     return size;
16740 }
16741 
16742 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)16743 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
16744 {
16745     /* no known/supported struct */
16746     vn_encode_simple_pointer(enc, NULL);
16747 }
16748 
16749 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)16750 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
16751 {
16752     /* skip val->{sType,pNext} */
16753     vn_encode_uint64_t(enc, &val->drmFormatModifier);
16754     vn_encode_VkSharingMode(enc, &val->sharingMode);
16755     vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
16756     if (val->pQueueFamilyIndices) {
16757         vn_encode_array_size(enc, val->queueFamilyIndexCount);
16758         vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
16759     } else {
16760         vn_encode_array_size(enc, 0);
16761     }
16762 }
16763 
16764 static inline void
vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageDrmFormatModifierInfoEXT * val)16765 vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *val)
16766 {
16767     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
16768     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT });
16769     vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_pnext(enc, val->pNext);
16770     vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, val);
16771 }
16772 
16773 /* struct VkPhysicalDeviceImageFormatInfo2 chain */
16774 
16775 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void * val)16776 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(const void *val)
16777 {
16778     const VkBaseInStructure *pnext = val;
16779     size_t size = 0;
16780 
16781     while (pnext) {
16782         switch ((int32_t)pnext->sType) {
16783         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
16784             size += vn_sizeof_simple_pointer(pnext);
16785             size += vn_sizeof_VkStructureType(&pnext->sType);
16786             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
16787             size += vn_sizeof_VkPhysicalDeviceExternalImageFormatInfo_self((const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
16788             return size;
16789         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
16790             size += vn_sizeof_simple_pointer(pnext);
16791             size += vn_sizeof_VkStructureType(&pnext->sType);
16792             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
16793             size += vn_sizeof_VkImageFormatListCreateInfo_self((const VkImageFormatListCreateInfo *)pnext);
16794             return size;
16795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
16796             if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
16797                 break;
16798             size += vn_sizeof_simple_pointer(pnext);
16799             size += vn_sizeof_VkStructureType(&pnext->sType);
16800             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
16801             size += vn_sizeof_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self((const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
16802             return size;
16803         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
16804             size += vn_sizeof_simple_pointer(pnext);
16805             size += vn_sizeof_VkStructureType(&pnext->sType);
16806             size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(pnext->pNext);
16807             size += vn_sizeof_VkImageStencilUsageCreateInfo_self((const VkImageStencilUsageCreateInfo *)pnext);
16808             return size;
16809         default:
16810             /* ignore unknown/unsupported struct */
16811             break;
16812         }
16813         pnext = pnext->pNext;
16814     }
16815 
16816     return vn_sizeof_simple_pointer(NULL);
16817 }
16818 
16819 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 * val)16820 vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(const VkPhysicalDeviceImageFormatInfo2 *val)
16821 {
16822     size_t size = 0;
16823     /* skip val->{sType,pNext} */
16824     size += vn_sizeof_VkFormat(&val->format);
16825     size += vn_sizeof_VkImageType(&val->type);
16826     size += vn_sizeof_VkImageTiling(&val->tiling);
16827     size += vn_sizeof_VkFlags(&val->usage);
16828     size += vn_sizeof_VkFlags(&val->flags);
16829     return size;
16830 }
16831 
16832 static inline size_t
vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 * val)16833 vn_sizeof_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2 *val)
16834 {
16835     size_t size = 0;
16836 
16837     size += vn_sizeof_VkStructureType(&val->sType);
16838     size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_pnext(val->pNext);
16839     size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2_self(val);
16840 
16841     return size;
16842 }
16843 
16844 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)16845 vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
16846 {
16847     const VkBaseInStructure *pnext = val;
16848 
16849     while (pnext) {
16850         switch ((int32_t)pnext->sType) {
16851         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
16852             vn_encode_simple_pointer(enc, pnext);
16853             vn_encode_VkStructureType(enc, &pnext->sType);
16854             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
16855             vn_encode_VkPhysicalDeviceExternalImageFormatInfo_self(enc, (const VkPhysicalDeviceExternalImageFormatInfo *)pnext);
16856             return;
16857         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
16858             vn_encode_simple_pointer(enc, pnext);
16859             vn_encode_VkStructureType(enc, &pnext->sType);
16860             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
16861             vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
16862             return;
16863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
16864             if (!vn_cs_renderer_protocol_has_extension(159 /* VK_EXT_image_drm_format_modifier */))
16865                 break;
16866             vn_encode_simple_pointer(enc, pnext);
16867             vn_encode_VkStructureType(enc, &pnext->sType);
16868             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
16869             vn_encode_VkPhysicalDeviceImageDrmFormatModifierInfoEXT_self(enc, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)pnext);
16870             return;
16871         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
16872             vn_encode_simple_pointer(enc, pnext);
16873             vn_encode_VkStructureType(enc, &pnext->sType);
16874             vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, pnext->pNext);
16875             vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
16876             return;
16877         default:
16878             /* ignore unknown/unsupported struct */
16879             break;
16880         }
16881         pnext = pnext->pNext;
16882     }
16883 
16884     vn_encode_simple_pointer(enc, NULL);
16885 }
16886 
16887 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)16888 vn_encode_VkPhysicalDeviceImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
16889 {
16890     /* skip val->{sType,pNext} */
16891     vn_encode_VkFormat(enc, &val->format);
16892     vn_encode_VkImageType(enc, &val->type);
16893     vn_encode_VkImageTiling(enc, &val->tiling);
16894     vn_encode_VkFlags(enc, &val->usage);
16895     vn_encode_VkFlags(enc, &val->flags);
16896 }
16897 
16898 static inline void
vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceImageFormatInfo2 * val)16899 vn_encode_VkPhysicalDeviceImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceImageFormatInfo2 *val)
16900 {
16901     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
16902     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 });
16903     vn_encode_VkPhysicalDeviceImageFormatInfo2_pnext(enc, val->pNext);
16904     vn_encode_VkPhysicalDeviceImageFormatInfo2_self(enc, val);
16905 }
16906 
16907 /* struct VkExternalMemoryProperties */
16908 
16909 static inline size_t
vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties * val)16910 vn_sizeof_VkExternalMemoryProperties(const VkExternalMemoryProperties *val)
16911 {
16912     size_t size = 0;
16913     size += vn_sizeof_VkFlags(&val->externalMemoryFeatures);
16914     size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
16915     size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
16916     return size;
16917 }
16918 
16919 static inline void
vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder * dec,VkExternalMemoryProperties * val)16920 vn_decode_VkExternalMemoryProperties(struct vn_cs_decoder *dec, VkExternalMemoryProperties *val)
16921 {
16922     vn_decode_VkFlags(dec, &val->externalMemoryFeatures);
16923     vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
16924     vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
16925 }
16926 
16927 static inline size_t
vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties * val)16928 vn_sizeof_VkExternalMemoryProperties_partial(const VkExternalMemoryProperties *val)
16929 {
16930     size_t size = 0;
16931     /* skip val->externalMemoryFeatures */
16932     /* skip val->exportFromImportedHandleTypes */
16933     /* skip val->compatibleHandleTypes */
16934     return size;
16935 }
16936 
16937 static inline void
vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder * enc,const VkExternalMemoryProperties * val)16938 vn_encode_VkExternalMemoryProperties_partial(struct vn_cs_encoder *enc, const VkExternalMemoryProperties *val)
16939 {
16940     /* skip val->externalMemoryFeatures */
16941     /* skip val->exportFromImportedHandleTypes */
16942     /* skip val->compatibleHandleTypes */
16943 }
16944 
16945 /* struct VkExternalImageFormatProperties chain */
16946 
16947 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext(const void * val)16948 vn_sizeof_VkExternalImageFormatProperties_pnext(const void *val)
16949 {
16950     /* no known/supported struct */
16951     return vn_sizeof_simple_pointer(NULL);
16952 }
16953 
16954 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties * val)16955 vn_sizeof_VkExternalImageFormatProperties_self(const VkExternalImageFormatProperties *val)
16956 {
16957     size_t size = 0;
16958     /* skip val->{sType,pNext} */
16959     size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
16960     return size;
16961 }
16962 
16963 static inline size_t
vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties * val)16964 vn_sizeof_VkExternalImageFormatProperties(const VkExternalImageFormatProperties *val)
16965 {
16966     size_t size = 0;
16967 
16968     size += vn_sizeof_VkStructureType(&val->sType);
16969     size += vn_sizeof_VkExternalImageFormatProperties_pnext(val->pNext);
16970     size += vn_sizeof_VkExternalImageFormatProperties_self(val);
16971 
16972     return size;
16973 }
16974 
16975 static inline void
vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)16976 vn_decode_VkExternalImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
16977 {
16978     /* no known/supported struct */
16979     if (vn_decode_simple_pointer(dec))
16980         assert(false);
16981 }
16982 
16983 static inline void
vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)16984 vn_decode_VkExternalImageFormatProperties_self(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
16985 {
16986     /* skip val->{sType,pNext} */
16987     vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
16988 }
16989 
16990 static inline void
vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder * dec,VkExternalImageFormatProperties * val)16991 vn_decode_VkExternalImageFormatProperties(struct vn_cs_decoder *dec, VkExternalImageFormatProperties *val)
16992 {
16993     VkStructureType stype;
16994     vn_decode_VkStructureType(dec, &stype);
16995     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
16996 
16997     assert(val->sType == stype);
16998     vn_decode_VkExternalImageFormatProperties_pnext(dec, val->pNext);
16999     vn_decode_VkExternalImageFormatProperties_self(dec, val);
17000 }
17001 
17002 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void * val)17003 vn_sizeof_VkExternalImageFormatProperties_pnext_partial(const void *val)
17004 {
17005     /* no known/supported struct */
17006     return vn_sizeof_simple_pointer(NULL);
17007 }
17008 
17009 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties * val)17010 vn_sizeof_VkExternalImageFormatProperties_self_partial(const VkExternalImageFormatProperties *val)
17011 {
17012     size_t size = 0;
17013     /* skip val->{sType,pNext} */
17014     size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
17015     return size;
17016 }
17017 
17018 static inline size_t
vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties * val)17019 vn_sizeof_VkExternalImageFormatProperties_partial(const VkExternalImageFormatProperties *val)
17020 {
17021     size_t size = 0;
17022 
17023     size += vn_sizeof_VkStructureType(&val->sType);
17024     size += vn_sizeof_VkExternalImageFormatProperties_pnext_partial(val->pNext);
17025     size += vn_sizeof_VkExternalImageFormatProperties_self_partial(val);
17026 
17027     return size;
17028 }
17029 
17030 static inline void
vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)17031 vn_encode_VkExternalImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17032 {
17033     /* no known/supported struct */
17034     vn_encode_simple_pointer(enc, NULL);
17035 }
17036 
17037 static inline void
vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)17038 vn_encode_VkExternalImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
17039 {
17040     /* skip val->{sType,pNext} */
17041     vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
17042 }
17043 
17044 static inline void
vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkExternalImageFormatProperties * val)17045 vn_encode_VkExternalImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkExternalImageFormatProperties *val)
17046 {
17047     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
17048     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES });
17049     vn_encode_VkExternalImageFormatProperties_pnext_partial(enc, val->pNext);
17050     vn_encode_VkExternalImageFormatProperties_self_partial(enc, val);
17051 }
17052 
17053 /* struct VkSamplerYcbcrConversionImageFormatProperties chain */
17054 
17055 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void * val)17056 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(const void *val)
17057 {
17058     /* no known/supported struct */
17059     return vn_sizeof_simple_pointer(NULL);
17060 }
17061 
17062 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties * val)17063 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(const VkSamplerYcbcrConversionImageFormatProperties *val)
17064 {
17065     size_t size = 0;
17066     /* skip val->{sType,pNext} */
17067     size += vn_sizeof_uint32_t(&val->combinedImageSamplerDescriptorCount);
17068     return size;
17069 }
17070 
17071 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties * val)17072 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties *val)
17073 {
17074     size_t size = 0;
17075 
17076     size += vn_sizeof_VkStructureType(&val->sType);
17077     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext(val->pNext);
17078     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self(val);
17079 
17080     return size;
17081 }
17082 
17083 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder * dec,const void * val)17084 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(struct vn_cs_decoder *dec, const void *val)
17085 {
17086     /* no known/supported struct */
17087     if (vn_decode_simple_pointer(dec))
17088         assert(false);
17089 }
17090 
17091 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)17092 vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
17093 {
17094     /* skip val->{sType,pNext} */
17095     vn_decode_uint32_t(dec, &val->combinedImageSamplerDescriptorCount);
17096 }
17097 
17098 static inline void
vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder * dec,VkSamplerYcbcrConversionImageFormatProperties * val)17099 vn_decode_VkSamplerYcbcrConversionImageFormatProperties(struct vn_cs_decoder *dec, VkSamplerYcbcrConversionImageFormatProperties *val)
17100 {
17101     VkStructureType stype;
17102     vn_decode_VkStructureType(dec, &stype);
17103     assert(stype == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
17104 
17105     assert(val->sType == stype);
17106     vn_decode_VkSamplerYcbcrConversionImageFormatProperties_pnext(dec, val->pNext);
17107     vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, val);
17108 }
17109 
17110 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void * val)17111 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(const void *val)
17112 {
17113     /* no known/supported struct */
17114     return vn_sizeof_simple_pointer(NULL);
17115 }
17116 
17117 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)17118 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
17119 {
17120     size_t size = 0;
17121     /* skip val->{sType,pNext} */
17122     /* skip val->combinedImageSamplerDescriptorCount */
17123     return size;
17124 }
17125 
17126 static inline size_t
vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties * val)17127 vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_partial(const VkSamplerYcbcrConversionImageFormatProperties *val)
17128 {
17129     size_t size = 0;
17130 
17131     size += vn_sizeof_VkStructureType(&val->sType);
17132     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(val->pNext);
17133     size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial(val);
17134 
17135     return size;
17136 }
17137 
17138 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)17139 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17140 {
17141     /* no known/supported struct */
17142     vn_encode_simple_pointer(enc, NULL);
17143 }
17144 
17145 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)17146 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
17147 {
17148     /* skip val->{sType,pNext} */
17149     /* skip val->combinedImageSamplerDescriptorCount */
17150 }
17151 
17152 static inline void
vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder * enc,const VkSamplerYcbcrConversionImageFormatProperties * val)17153 vn_encode_VkSamplerYcbcrConversionImageFormatProperties_partial(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionImageFormatProperties *val)
17154 {
17155     assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
17156     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES });
17157     vn_encode_VkSamplerYcbcrConversionImageFormatProperties_pnext_partial(enc, val->pNext);
17158     vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, val);
17159 }
17160 
17161 /* struct VkImageFormatProperties2 chain */
17162 
17163 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext(const void * val)17164 vn_sizeof_VkImageFormatProperties2_pnext(const void *val)
17165 {
17166     const VkBaseInStructure *pnext = val;
17167     size_t size = 0;
17168 
17169     while (pnext) {
17170         switch ((int32_t)pnext->sType) {
17171         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
17172             size += vn_sizeof_simple_pointer(pnext);
17173             size += vn_sizeof_VkStructureType(&pnext->sType);
17174             size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
17175             size += vn_sizeof_VkExternalImageFormatProperties_self((const VkExternalImageFormatProperties *)pnext);
17176             return size;
17177         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
17178             size += vn_sizeof_simple_pointer(pnext);
17179             size += vn_sizeof_VkStructureType(&pnext->sType);
17180             size += vn_sizeof_VkImageFormatProperties2_pnext(pnext->pNext);
17181             size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
17182             return size;
17183         default:
17184             /* ignore unknown/unsupported struct */
17185             break;
17186         }
17187         pnext = pnext->pNext;
17188     }
17189 
17190     return vn_sizeof_simple_pointer(NULL);
17191 }
17192 
17193 static inline size_t
vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 * val)17194 vn_sizeof_VkImageFormatProperties2_self(const VkImageFormatProperties2 *val)
17195 {
17196     size_t size = 0;
17197     /* skip val->{sType,pNext} */
17198     size += vn_sizeof_VkImageFormatProperties(&val->imageFormatProperties);
17199     return size;
17200 }
17201 
17202 static inline size_t
vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 * val)17203 vn_sizeof_VkImageFormatProperties2(const VkImageFormatProperties2 *val)
17204 {
17205     size_t size = 0;
17206 
17207     size += vn_sizeof_VkStructureType(&val->sType);
17208     size += vn_sizeof_VkImageFormatProperties2_pnext(val->pNext);
17209     size += vn_sizeof_VkImageFormatProperties2_self(val);
17210 
17211     return size;
17212 }
17213 
17214 static inline void
vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)17215 vn_decode_VkImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
17216 {
17217     VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
17218     VkStructureType stype;
17219 
17220     if (!vn_decode_simple_pointer(dec))
17221         return;
17222 
17223     vn_decode_VkStructureType(dec, &stype);
17224     while (true) {
17225         assert(pnext);
17226         if (pnext->sType == stype)
17227             break;
17228 
17229         pnext = pnext->pNext;
17230     }
17231 
17232     switch ((int32_t)pnext->sType) {
17233     case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
17234         vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
17235         vn_decode_VkExternalImageFormatProperties_self(dec, (VkExternalImageFormatProperties *)pnext);
17236         break;
17237     case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
17238         vn_decode_VkImageFormatProperties2_pnext(dec, pnext->pNext);
17239         vn_decode_VkSamplerYcbcrConversionImageFormatProperties_self(dec, (VkSamplerYcbcrConversionImageFormatProperties *)pnext);
17240         break;
17241     default:
17242         assert(false);
17243         break;
17244     }
17245 }
17246 
17247 static inline void
vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)17248 vn_decode_VkImageFormatProperties2_self(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
17249 {
17250     /* skip val->{sType,pNext} */
17251     vn_decode_VkImageFormatProperties(dec, &val->imageFormatProperties);
17252 }
17253 
17254 static inline void
vn_decode_VkImageFormatProperties2(struct vn_cs_decoder * dec,VkImageFormatProperties2 * val)17255 vn_decode_VkImageFormatProperties2(struct vn_cs_decoder *dec, VkImageFormatProperties2 *val)
17256 {
17257     VkStructureType stype;
17258     vn_decode_VkStructureType(dec, &stype);
17259     assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
17260 
17261     assert(val->sType == stype);
17262     vn_decode_VkImageFormatProperties2_pnext(dec, val->pNext);
17263     vn_decode_VkImageFormatProperties2_self(dec, val);
17264 }
17265 
17266 static inline size_t
vn_sizeof_VkImageFormatProperties2_pnext_partial(const void * val)17267 vn_sizeof_VkImageFormatProperties2_pnext_partial(const void *val)
17268 {
17269     const VkBaseInStructure *pnext = val;
17270     size_t size = 0;
17271 
17272     while (pnext) {
17273         switch ((int32_t)pnext->sType) {
17274         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
17275             size += vn_sizeof_simple_pointer(pnext);
17276             size += vn_sizeof_VkStructureType(&pnext->sType);
17277             size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
17278             size += vn_sizeof_VkExternalImageFormatProperties_self_partial((const VkExternalImageFormatProperties *)pnext);
17279             return size;
17280         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
17281             size += vn_sizeof_simple_pointer(pnext);
17282             size += vn_sizeof_VkStructureType(&pnext->sType);
17283             size += vn_sizeof_VkImageFormatProperties2_pnext_partial(pnext->pNext);
17284             size += vn_sizeof_VkSamplerYcbcrConversionImageFormatProperties_self_partial((const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
17285             return size;
17286         default:
17287             /* ignore unknown/unsupported struct */
17288             break;
17289         }
17290         pnext = pnext->pNext;
17291     }
17292 
17293     return vn_sizeof_simple_pointer(NULL);
17294 }
17295 
17296 static inline size_t
vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 * val)17297 vn_sizeof_VkImageFormatProperties2_self_partial(const VkImageFormatProperties2 *val)
17298 {
17299     size_t size = 0;
17300     /* skip val->{sType,pNext} */
17301     size += vn_sizeof_VkImageFormatProperties_partial(&val->imageFormatProperties);
17302     return size;
17303 }
17304 
17305 static inline size_t
vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 * val)17306 vn_sizeof_VkImageFormatProperties2_partial(const VkImageFormatProperties2 *val)
17307 {
17308     size_t size = 0;
17309 
17310     size += vn_sizeof_VkStructureType(&val->sType);
17311     size += vn_sizeof_VkImageFormatProperties2_pnext_partial(val->pNext);
17312     size += vn_sizeof_VkImageFormatProperties2_self_partial(val);
17313 
17314     return size;
17315 }
17316 
17317 static inline void
vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)17318 vn_encode_VkImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17319 {
17320     const VkBaseInStructure *pnext = val;
17321 
17322     while (pnext) {
17323         switch ((int32_t)pnext->sType) {
17324         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
17325             vn_encode_simple_pointer(enc, pnext);
17326             vn_encode_VkStructureType(enc, &pnext->sType);
17327             vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
17328             vn_encode_VkExternalImageFormatProperties_self_partial(enc, (const VkExternalImageFormatProperties *)pnext);
17329             return;
17330         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
17331             vn_encode_simple_pointer(enc, pnext);
17332             vn_encode_VkStructureType(enc, &pnext->sType);
17333             vn_encode_VkImageFormatProperties2_pnext_partial(enc, pnext->pNext);
17334             vn_encode_VkSamplerYcbcrConversionImageFormatProperties_self_partial(enc, (const VkSamplerYcbcrConversionImageFormatProperties *)pnext);
17335             return;
17336         default:
17337             /* ignore unknown/unsupported struct */
17338             break;
17339         }
17340         pnext = pnext->pNext;
17341     }
17342 
17343     vn_encode_simple_pointer(enc, NULL);
17344 }
17345 
17346 static inline void
vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)17347 vn_encode_VkImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
17348 {
17349     /* skip val->{sType,pNext} */
17350     vn_encode_VkImageFormatProperties_partial(enc, &val->imageFormatProperties);
17351 }
17352 
17353 static inline void
vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkImageFormatProperties2 * val)17354 vn_encode_VkImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkImageFormatProperties2 *val)
17355 {
17356     assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
17357     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 });
17358     vn_encode_VkImageFormatProperties2_pnext_partial(enc, val->pNext);
17359     vn_encode_VkImageFormatProperties2_self_partial(enc, val);
17360 }
17361 
17362 /* struct VkQueueFamilyProperties2 chain */
17363 
17364 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext(const void * val)17365 vn_sizeof_VkQueueFamilyProperties2_pnext(const void *val)
17366 {
17367     /* no known/supported struct */
17368     return vn_sizeof_simple_pointer(NULL);
17369 }
17370 
17371 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 * val)17372 vn_sizeof_VkQueueFamilyProperties2_self(const VkQueueFamilyProperties2 *val)
17373 {
17374     size_t size = 0;
17375     /* skip val->{sType,pNext} */
17376     size += vn_sizeof_VkQueueFamilyProperties(&val->queueFamilyProperties);
17377     return size;
17378 }
17379 
17380 static inline size_t
vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 * val)17381 vn_sizeof_VkQueueFamilyProperties2(const VkQueueFamilyProperties2 *val)
17382 {
17383     size_t size = 0;
17384 
17385     size += vn_sizeof_VkStructureType(&val->sType);
17386     size += vn_sizeof_VkQueueFamilyProperties2_pnext(val->pNext);
17387     size += vn_sizeof_VkQueueFamilyProperties2_self(val);
17388 
17389     return size;
17390 }
17391 
17392 static inline void
vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder * dec,const void * val)17393 vn_decode_VkQueueFamilyProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
17394 {
17395     /* no known/supported struct */
17396     if (vn_decode_simple_pointer(dec))
17397         assert(false);
17398 }
17399 
17400 static inline void
vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)17401 vn_decode_VkQueueFamilyProperties2_self(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
17402 {
17403     /* skip val->{sType,pNext} */
17404     vn_decode_VkQueueFamilyProperties(dec, &val->queueFamilyProperties);
17405 }
17406 
17407 static inline void
vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder * dec,VkQueueFamilyProperties2 * val)17408 vn_decode_VkQueueFamilyProperties2(struct vn_cs_decoder *dec, VkQueueFamilyProperties2 *val)
17409 {
17410     VkStructureType stype;
17411     vn_decode_VkStructureType(dec, &stype);
17412     assert(stype == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
17413 
17414     assert(val->sType == stype);
17415     vn_decode_VkQueueFamilyProperties2_pnext(dec, val->pNext);
17416     vn_decode_VkQueueFamilyProperties2_self(dec, val);
17417 }
17418 
17419 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void * val)17420 vn_sizeof_VkQueueFamilyProperties2_pnext_partial(const void *val)
17421 {
17422     /* no known/supported struct */
17423     return vn_sizeof_simple_pointer(NULL);
17424 }
17425 
17426 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 * val)17427 vn_sizeof_VkQueueFamilyProperties2_self_partial(const VkQueueFamilyProperties2 *val)
17428 {
17429     size_t size = 0;
17430     /* skip val->{sType,pNext} */
17431     size += vn_sizeof_VkQueueFamilyProperties_partial(&val->queueFamilyProperties);
17432     return size;
17433 }
17434 
17435 static inline size_t
vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 * val)17436 vn_sizeof_VkQueueFamilyProperties2_partial(const VkQueueFamilyProperties2 *val)
17437 {
17438     size_t size = 0;
17439 
17440     size += vn_sizeof_VkStructureType(&val->sType);
17441     size += vn_sizeof_VkQueueFamilyProperties2_pnext_partial(val->pNext);
17442     size += vn_sizeof_VkQueueFamilyProperties2_self_partial(val);
17443 
17444     return size;
17445 }
17446 
17447 static inline void
vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)17448 vn_encode_VkQueueFamilyProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17449 {
17450     /* no known/supported struct */
17451     vn_encode_simple_pointer(enc, NULL);
17452 }
17453 
17454 static inline void
vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)17455 vn_encode_VkQueueFamilyProperties2_self_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
17456 {
17457     /* skip val->{sType,pNext} */
17458     vn_encode_VkQueueFamilyProperties_partial(enc, &val->queueFamilyProperties);
17459 }
17460 
17461 static inline void
vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder * enc,const VkQueueFamilyProperties2 * val)17462 vn_encode_VkQueueFamilyProperties2_partial(struct vn_cs_encoder *enc, const VkQueueFamilyProperties2 *val)
17463 {
17464     assert(val->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
17465     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 });
17466     vn_encode_VkQueueFamilyProperties2_pnext_partial(enc, val->pNext);
17467     vn_encode_VkQueueFamilyProperties2_self_partial(enc, val);
17468 }
17469 
17470 /* struct VkPhysicalDeviceMemoryProperties2 chain */
17471 
17472 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void * val)17473 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(const void *val)
17474 {
17475     /* no known/supported struct */
17476     return vn_sizeof_simple_pointer(NULL);
17477 }
17478 
17479 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 * val)17480 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(const VkPhysicalDeviceMemoryProperties2 *val)
17481 {
17482     size_t size = 0;
17483     /* skip val->{sType,pNext} */
17484     size += vn_sizeof_VkPhysicalDeviceMemoryProperties(&val->memoryProperties);
17485     return size;
17486 }
17487 
17488 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 * val)17489 vn_sizeof_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2 *val)
17490 {
17491     size_t size = 0;
17492 
17493     size += vn_sizeof_VkStructureType(&val->sType);
17494     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext(val->pNext);
17495     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self(val);
17496 
17497     return size;
17498 }
17499 
17500 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder * dec,const void * val)17501 vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
17502 {
17503     /* no known/supported struct */
17504     if (vn_decode_simple_pointer(dec))
17505         assert(false);
17506 }
17507 
17508 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)17509 vn_decode_VkPhysicalDeviceMemoryProperties2_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
17510 {
17511     /* skip val->{sType,pNext} */
17512     vn_decode_VkPhysicalDeviceMemoryProperties(dec, &val->memoryProperties);
17513 }
17514 
17515 static inline void
vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder * dec,VkPhysicalDeviceMemoryProperties2 * val)17516 vn_decode_VkPhysicalDeviceMemoryProperties2(struct vn_cs_decoder *dec, VkPhysicalDeviceMemoryProperties2 *val)
17517 {
17518     VkStructureType stype;
17519     vn_decode_VkStructureType(dec, &stype);
17520     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
17521 
17522     assert(val->sType == stype);
17523     vn_decode_VkPhysicalDeviceMemoryProperties2_pnext(dec, val->pNext);
17524     vn_decode_VkPhysicalDeviceMemoryProperties2_self(dec, val);
17525 }
17526 
17527 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void * val)17528 vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(const void *val)
17529 {
17530     /* no known/supported struct */
17531     return vn_sizeof_simple_pointer(NULL);
17532 }
17533 
17534 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 * val)17535 vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(const VkPhysicalDeviceMemoryProperties2 *val)
17536 {
17537     size_t size = 0;
17538     /* skip val->{sType,pNext} */
17539     size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(&val->memoryProperties);
17540     return size;
17541 }
17542 
17543 static inline size_t
vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 * val)17544 vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(const VkPhysicalDeviceMemoryProperties2 *val)
17545 {
17546     size_t size = 0;
17547 
17548     size += vn_sizeof_VkStructureType(&val->sType);
17549     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_pnext_partial(val->pNext);
17550     size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_self_partial(val);
17551 
17552     return size;
17553 }
17554 
17555 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)17556 vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17557 {
17558     /* no known/supported struct */
17559     vn_encode_simple_pointer(enc, NULL);
17560 }
17561 
17562 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)17563 vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
17564 {
17565     /* skip val->{sType,pNext} */
17566     vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, &val->memoryProperties);
17567 }
17568 
17569 static inline void
vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceMemoryProperties2 * val)17570 vn_encode_VkPhysicalDeviceMemoryProperties2_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMemoryProperties2 *val)
17571 {
17572     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
17573     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 });
17574     vn_encode_VkPhysicalDeviceMemoryProperties2_pnext_partial(enc, val->pNext);
17575     vn_encode_VkPhysicalDeviceMemoryProperties2_self_partial(enc, val);
17576 }
17577 
17578 /* struct VkPhysicalDeviceSparseImageFormatInfo2 chain */
17579 
17580 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void * val)17581 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(const void *val)
17582 {
17583     /* no known/supported struct */
17584     return vn_sizeof_simple_pointer(NULL);
17585 }
17586 
17587 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 * val)17588 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
17589 {
17590     size_t size = 0;
17591     /* skip val->{sType,pNext} */
17592     size += vn_sizeof_VkFormat(&val->format);
17593     size += vn_sizeof_VkImageType(&val->type);
17594     size += vn_sizeof_VkSampleCountFlagBits(&val->samples);
17595     size += vn_sizeof_VkFlags(&val->usage);
17596     size += vn_sizeof_VkImageTiling(&val->tiling);
17597     return size;
17598 }
17599 
17600 static inline size_t
vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 * val)17601 vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2 *val)
17602 {
17603     size_t size = 0;
17604 
17605     size += vn_sizeof_VkStructureType(&val->sType);
17606     size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_pnext(val->pNext);
17607     size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2_self(val);
17608 
17609     return size;
17610 }
17611 
17612 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder * enc,const void * val)17613 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
17614 {
17615     /* no known/supported struct */
17616     vn_encode_simple_pointer(enc, NULL);
17617 }
17618 
17619 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)17620 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
17621 {
17622     /* skip val->{sType,pNext} */
17623     vn_encode_VkFormat(enc, &val->format);
17624     vn_encode_VkImageType(enc, &val->type);
17625     vn_encode_VkSampleCountFlagBits(enc, &val->samples);
17626     vn_encode_VkFlags(enc, &val->usage);
17627     vn_encode_VkImageTiling(enc, &val->tiling);
17628 }
17629 
17630 static inline void
vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder * enc,const VkPhysicalDeviceSparseImageFormatInfo2 * val)17631 vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(struct vn_cs_encoder *enc, const VkPhysicalDeviceSparseImageFormatInfo2 *val)
17632 {
17633     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2);
17634     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 });
17635     vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_pnext(enc, val->pNext);
17636     vn_encode_VkPhysicalDeviceSparseImageFormatInfo2_self(enc, val);
17637 }
17638 
17639 /* struct VkSparseImageFormatProperties2 chain */
17640 
17641 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext(const void * val)17642 vn_sizeof_VkSparseImageFormatProperties2_pnext(const void *val)
17643 {
17644     /* no known/supported struct */
17645     return vn_sizeof_simple_pointer(NULL);
17646 }
17647 
17648 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 * val)17649 vn_sizeof_VkSparseImageFormatProperties2_self(const VkSparseImageFormatProperties2 *val)
17650 {
17651     size_t size = 0;
17652     /* skip val->{sType,pNext} */
17653     size += vn_sizeof_VkSparseImageFormatProperties(&val->properties);
17654     return size;
17655 }
17656 
17657 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 * val)17658 vn_sizeof_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2 *val)
17659 {
17660     size_t size = 0;
17661 
17662     size += vn_sizeof_VkStructureType(&val->sType);
17663     size += vn_sizeof_VkSparseImageFormatProperties2_pnext(val->pNext);
17664     size += vn_sizeof_VkSparseImageFormatProperties2_self(val);
17665 
17666     return size;
17667 }
17668 
17669 static inline void
vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder * dec,const void * val)17670 vn_decode_VkSparseImageFormatProperties2_pnext(struct vn_cs_decoder *dec, const void *val)
17671 {
17672     /* no known/supported struct */
17673     if (vn_decode_simple_pointer(dec))
17674         assert(false);
17675 }
17676 
17677 static inline void
vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)17678 vn_decode_VkSparseImageFormatProperties2_self(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
17679 {
17680     /* skip val->{sType,pNext} */
17681     vn_decode_VkSparseImageFormatProperties(dec, &val->properties);
17682 }
17683 
17684 static inline void
vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder * dec,VkSparseImageFormatProperties2 * val)17685 vn_decode_VkSparseImageFormatProperties2(struct vn_cs_decoder *dec, VkSparseImageFormatProperties2 *val)
17686 {
17687     VkStructureType stype;
17688     vn_decode_VkStructureType(dec, &stype);
17689     assert(stype == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
17690 
17691     assert(val->sType == stype);
17692     vn_decode_VkSparseImageFormatProperties2_pnext(dec, val->pNext);
17693     vn_decode_VkSparseImageFormatProperties2_self(dec, val);
17694 }
17695 
17696 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void * val)17697 vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(const void *val)
17698 {
17699     /* no known/supported struct */
17700     return vn_sizeof_simple_pointer(NULL);
17701 }
17702 
17703 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 * val)17704 vn_sizeof_VkSparseImageFormatProperties2_self_partial(const VkSparseImageFormatProperties2 *val)
17705 {
17706     size_t size = 0;
17707     /* skip val->{sType,pNext} */
17708     size += vn_sizeof_VkSparseImageFormatProperties_partial(&val->properties);
17709     return size;
17710 }
17711 
17712 static inline size_t
vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 * val)17713 vn_sizeof_VkSparseImageFormatProperties2_partial(const VkSparseImageFormatProperties2 *val)
17714 {
17715     size_t size = 0;
17716 
17717     size += vn_sizeof_VkStructureType(&val->sType);
17718     size += vn_sizeof_VkSparseImageFormatProperties2_pnext_partial(val->pNext);
17719     size += vn_sizeof_VkSparseImageFormatProperties2_self_partial(val);
17720 
17721     return size;
17722 }
17723 
17724 static inline void
vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder * enc,const void * val)17725 vn_encode_VkSparseImageFormatProperties2_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17726 {
17727     /* no known/supported struct */
17728     vn_encode_simple_pointer(enc, NULL);
17729 }
17730 
17731 static inline void
vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)17732 vn_encode_VkSparseImageFormatProperties2_self_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
17733 {
17734     /* skip val->{sType,pNext} */
17735     vn_encode_VkSparseImageFormatProperties_partial(enc, &val->properties);
17736 }
17737 
17738 static inline void
vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder * enc,const VkSparseImageFormatProperties2 * val)17739 vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, const VkSparseImageFormatProperties2 *val)
17740 {
17741     assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
17742     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 });
17743     vn_encode_VkSparseImageFormatProperties2_pnext_partial(enc, val->pNext);
17744     vn_encode_VkSparseImageFormatProperties2_self_partial(enc, val);
17745 }
17746 
17747 /* struct VkPhysicalDeviceExternalBufferInfo chain */
17748 
17749 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void * val)17750 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(const void *val)
17751 {
17752     /* no known/supported struct */
17753     return vn_sizeof_simple_pointer(NULL);
17754 }
17755 
17756 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo * val)17757 vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(const VkPhysicalDeviceExternalBufferInfo *val)
17758 {
17759     size_t size = 0;
17760     /* skip val->{sType,pNext} */
17761     size += vn_sizeof_VkFlags(&val->flags);
17762     size += vn_sizeof_VkFlags(&val->usage);
17763     size += vn_sizeof_VkExternalMemoryHandleTypeFlagBits(&val->handleType);
17764     return size;
17765 }
17766 
17767 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo * val)17768 vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo *val)
17769 {
17770     size_t size = 0;
17771 
17772     size += vn_sizeof_VkStructureType(&val->sType);
17773     size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(val->pNext);
17774     size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_self(val);
17775 
17776     return size;
17777 }
17778 
17779 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder * enc,const void * val)17780 vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(struct vn_cs_encoder *enc, const void *val)
17781 {
17782     /* no known/supported struct */
17783     vn_encode_simple_pointer(enc, NULL);
17784 }
17785 
17786 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)17787 vn_encode_VkPhysicalDeviceExternalBufferInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
17788 {
17789     /* skip val->{sType,pNext} */
17790     vn_encode_VkFlags(enc, &val->flags);
17791     vn_encode_VkFlags(enc, &val->usage);
17792     vn_encode_VkExternalMemoryHandleTypeFlagBits(enc, &val->handleType);
17793 }
17794 
17795 static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalBufferInfo * val)17796 vn_encode_VkPhysicalDeviceExternalBufferInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalBufferInfo *val)
17797 {
17798     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO);
17799     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO });
17800     vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, val->pNext);
17801     vn_encode_VkPhysicalDeviceExternalBufferInfo_self(enc, val);
17802 }
17803 
17804 /* struct VkExternalBufferProperties chain */
17805 
17806 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext(const void * val)17807 vn_sizeof_VkExternalBufferProperties_pnext(const void *val)
17808 {
17809     /* no known/supported struct */
17810     return vn_sizeof_simple_pointer(NULL);
17811 }
17812 
17813 static inline size_t
vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties * val)17814 vn_sizeof_VkExternalBufferProperties_self(const VkExternalBufferProperties *val)
17815 {
17816     size_t size = 0;
17817     /* skip val->{sType,pNext} */
17818     size += vn_sizeof_VkExternalMemoryProperties(&val->externalMemoryProperties);
17819     return size;
17820 }
17821 
17822 static inline size_t
vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties * val)17823 vn_sizeof_VkExternalBufferProperties(const VkExternalBufferProperties *val)
17824 {
17825     size_t size = 0;
17826 
17827     size += vn_sizeof_VkStructureType(&val->sType);
17828     size += vn_sizeof_VkExternalBufferProperties_pnext(val->pNext);
17829     size += vn_sizeof_VkExternalBufferProperties_self(val);
17830 
17831     return size;
17832 }
17833 
17834 static inline void
vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder * dec,const void * val)17835 vn_decode_VkExternalBufferProperties_pnext(struct vn_cs_decoder *dec, const void *val)
17836 {
17837     /* no known/supported struct */
17838     if (vn_decode_simple_pointer(dec))
17839         assert(false);
17840 }
17841 
17842 static inline void
vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)17843 vn_decode_VkExternalBufferProperties_self(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
17844 {
17845     /* skip val->{sType,pNext} */
17846     vn_decode_VkExternalMemoryProperties(dec, &val->externalMemoryProperties);
17847 }
17848 
17849 static inline void
vn_decode_VkExternalBufferProperties(struct vn_cs_decoder * dec,VkExternalBufferProperties * val)17850 vn_decode_VkExternalBufferProperties(struct vn_cs_decoder *dec, VkExternalBufferProperties *val)
17851 {
17852     VkStructureType stype;
17853     vn_decode_VkStructureType(dec, &stype);
17854     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
17855 
17856     assert(val->sType == stype);
17857     vn_decode_VkExternalBufferProperties_pnext(dec, val->pNext);
17858     vn_decode_VkExternalBufferProperties_self(dec, val);
17859 }
17860 
17861 static inline size_t
vn_sizeof_VkExternalBufferProperties_pnext_partial(const void * val)17862 vn_sizeof_VkExternalBufferProperties_pnext_partial(const void *val)
17863 {
17864     /* no known/supported struct */
17865     return vn_sizeof_simple_pointer(NULL);
17866 }
17867 
17868 static inline size_t
vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties * val)17869 vn_sizeof_VkExternalBufferProperties_self_partial(const VkExternalBufferProperties *val)
17870 {
17871     size_t size = 0;
17872     /* skip val->{sType,pNext} */
17873     size += vn_sizeof_VkExternalMemoryProperties_partial(&val->externalMemoryProperties);
17874     return size;
17875 }
17876 
17877 static inline size_t
vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties * val)17878 vn_sizeof_VkExternalBufferProperties_partial(const VkExternalBufferProperties *val)
17879 {
17880     size_t size = 0;
17881 
17882     size += vn_sizeof_VkStructureType(&val->sType);
17883     size += vn_sizeof_VkExternalBufferProperties_pnext_partial(val->pNext);
17884     size += vn_sizeof_VkExternalBufferProperties_self_partial(val);
17885 
17886     return size;
17887 }
17888 
17889 static inline void
vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)17890 vn_encode_VkExternalBufferProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
17891 {
17892     /* no known/supported struct */
17893     vn_encode_simple_pointer(enc, NULL);
17894 }
17895 
17896 static inline void
vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)17897 vn_encode_VkExternalBufferProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
17898 {
17899     /* skip val->{sType,pNext} */
17900     vn_encode_VkExternalMemoryProperties_partial(enc, &val->externalMemoryProperties);
17901 }
17902 
17903 static inline void
vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder * enc,const VkExternalBufferProperties * val)17904 vn_encode_VkExternalBufferProperties_partial(struct vn_cs_encoder *enc, const VkExternalBufferProperties *val)
17905 {
17906     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
17907     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES });
17908     vn_encode_VkExternalBufferProperties_pnext_partial(enc, val->pNext);
17909     vn_encode_VkExternalBufferProperties_self_partial(enc, val);
17910 }
17911 
17912 /* struct VkPhysicalDeviceExternalSemaphoreInfo chain */
17913 
17914 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void * val)17915 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(const void *val)
17916 {
17917     const VkBaseInStructure *pnext = val;
17918     size_t size = 0;
17919 
17920     while (pnext) {
17921         switch ((int32_t)pnext->sType) {
17922         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
17923             size += vn_sizeof_simple_pointer(pnext);
17924             size += vn_sizeof_VkStructureType(&pnext->sType);
17925             size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(pnext->pNext);
17926             size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
17927             return size;
17928         default:
17929             /* ignore unknown/unsupported struct */
17930             break;
17931         }
17932         pnext = pnext->pNext;
17933     }
17934 
17935     return vn_sizeof_simple_pointer(NULL);
17936 }
17937 
17938 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo * val)17939 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(const VkPhysicalDeviceExternalSemaphoreInfo *val)
17940 {
17941     size_t size = 0;
17942     /* skip val->{sType,pNext} */
17943     size += vn_sizeof_VkExternalSemaphoreHandleTypeFlagBits(&val->handleType);
17944     return size;
17945 }
17946 
17947 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo * val)17948 vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo *val)
17949 {
17950     size_t size = 0;
17951 
17952     size += vn_sizeof_VkStructureType(&val->sType);
17953     size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_pnext(val->pNext);
17954     size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo_self(val);
17955 
17956     return size;
17957 }
17958 
17959 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder * enc,const void * val)17960 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(struct vn_cs_encoder *enc, const void *val)
17961 {
17962     const VkBaseInStructure *pnext = val;
17963 
17964     while (pnext) {
17965         switch ((int32_t)pnext->sType) {
17966         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
17967             vn_encode_simple_pointer(enc, pnext);
17968             vn_encode_VkStructureType(enc, &pnext->sType);
17969             vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, pnext->pNext);
17970             vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
17971             return;
17972         default:
17973             /* ignore unknown/unsupported struct */
17974             break;
17975         }
17976         pnext = pnext->pNext;
17977     }
17978 
17979     vn_encode_simple_pointer(enc, NULL);
17980 }
17981 
17982 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)17983 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
17984 {
17985     /* skip val->{sType,pNext} */
17986     vn_encode_VkExternalSemaphoreHandleTypeFlagBits(enc, &val->handleType);
17987 }
17988 
17989 static inline void
vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalSemaphoreInfo * val)17990 vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalSemaphoreInfo *val)
17991 {
17992     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
17993     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO });
17994     vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_pnext(enc, val->pNext);
17995     vn_encode_VkPhysicalDeviceExternalSemaphoreInfo_self(enc, val);
17996 }
17997 
17998 /* struct VkExternalSemaphoreProperties chain */
17999 
18000 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext(const void * val)18001 vn_sizeof_VkExternalSemaphoreProperties_pnext(const void *val)
18002 {
18003     /* no known/supported struct */
18004     return vn_sizeof_simple_pointer(NULL);
18005 }
18006 
18007 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties * val)18008 vn_sizeof_VkExternalSemaphoreProperties_self(const VkExternalSemaphoreProperties *val)
18009 {
18010     size_t size = 0;
18011     /* skip val->{sType,pNext} */
18012     size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
18013     size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
18014     size += vn_sizeof_VkFlags(&val->externalSemaphoreFeatures);
18015     return size;
18016 }
18017 
18018 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties * val)18019 vn_sizeof_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties *val)
18020 {
18021     size_t size = 0;
18022 
18023     size += vn_sizeof_VkStructureType(&val->sType);
18024     size += vn_sizeof_VkExternalSemaphoreProperties_pnext(val->pNext);
18025     size += vn_sizeof_VkExternalSemaphoreProperties_self(val);
18026 
18027     return size;
18028 }
18029 
18030 static inline void
vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder * dec,const void * val)18031 vn_decode_VkExternalSemaphoreProperties_pnext(struct vn_cs_decoder *dec, const void *val)
18032 {
18033     /* no known/supported struct */
18034     if (vn_decode_simple_pointer(dec))
18035         assert(false);
18036 }
18037 
18038 static inline void
vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)18039 vn_decode_VkExternalSemaphoreProperties_self(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
18040 {
18041     /* skip val->{sType,pNext} */
18042     vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
18043     vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
18044     vn_decode_VkFlags(dec, &val->externalSemaphoreFeatures);
18045 }
18046 
18047 static inline void
vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder * dec,VkExternalSemaphoreProperties * val)18048 vn_decode_VkExternalSemaphoreProperties(struct vn_cs_decoder *dec, VkExternalSemaphoreProperties *val)
18049 {
18050     VkStructureType stype;
18051     vn_decode_VkStructureType(dec, &stype);
18052     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
18053 
18054     assert(val->sType == stype);
18055     vn_decode_VkExternalSemaphoreProperties_pnext(dec, val->pNext);
18056     vn_decode_VkExternalSemaphoreProperties_self(dec, val);
18057 }
18058 
18059 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void * val)18060 vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(const void *val)
18061 {
18062     /* no known/supported struct */
18063     return vn_sizeof_simple_pointer(NULL);
18064 }
18065 
18066 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties * val)18067 vn_sizeof_VkExternalSemaphoreProperties_self_partial(const VkExternalSemaphoreProperties *val)
18068 {
18069     size_t size = 0;
18070     /* skip val->{sType,pNext} */
18071     /* skip val->exportFromImportedHandleTypes */
18072     /* skip val->compatibleHandleTypes */
18073     /* skip val->externalSemaphoreFeatures */
18074     return size;
18075 }
18076 
18077 static inline size_t
vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties * val)18078 vn_sizeof_VkExternalSemaphoreProperties_partial(const VkExternalSemaphoreProperties *val)
18079 {
18080     size_t size = 0;
18081 
18082     size += vn_sizeof_VkStructureType(&val->sType);
18083     size += vn_sizeof_VkExternalSemaphoreProperties_pnext_partial(val->pNext);
18084     size += vn_sizeof_VkExternalSemaphoreProperties_self_partial(val);
18085 
18086     return size;
18087 }
18088 
18089 static inline void
vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)18090 vn_encode_VkExternalSemaphoreProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18091 {
18092     /* no known/supported struct */
18093     vn_encode_simple_pointer(enc, NULL);
18094 }
18095 
18096 static inline void
vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)18097 vn_encode_VkExternalSemaphoreProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
18098 {
18099     /* skip val->{sType,pNext} */
18100     /* skip val->exportFromImportedHandleTypes */
18101     /* skip val->compatibleHandleTypes */
18102     /* skip val->externalSemaphoreFeatures */
18103 }
18104 
18105 static inline void
vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder * enc,const VkExternalSemaphoreProperties * val)18106 vn_encode_VkExternalSemaphoreProperties_partial(struct vn_cs_encoder *enc, const VkExternalSemaphoreProperties *val)
18107 {
18108     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
18109     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES });
18110     vn_encode_VkExternalSemaphoreProperties_pnext_partial(enc, val->pNext);
18111     vn_encode_VkExternalSemaphoreProperties_self_partial(enc, val);
18112 }
18113 
18114 /* struct VkPhysicalDeviceExternalFenceInfo chain */
18115 
18116 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void * val)18117 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(const void *val)
18118 {
18119     /* no known/supported struct */
18120     return vn_sizeof_simple_pointer(NULL);
18121 }
18122 
18123 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo * val)18124 vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(const VkPhysicalDeviceExternalFenceInfo *val)
18125 {
18126     size_t size = 0;
18127     /* skip val->{sType,pNext} */
18128     size += vn_sizeof_VkExternalFenceHandleTypeFlagBits(&val->handleType);
18129     return size;
18130 }
18131 
18132 static inline size_t
vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo * val)18133 vn_sizeof_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo *val)
18134 {
18135     size_t size = 0;
18136 
18137     size += vn_sizeof_VkStructureType(&val->sType);
18138     size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_pnext(val->pNext);
18139     size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo_self(val);
18140 
18141     return size;
18142 }
18143 
18144 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder * enc,const void * val)18145 vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(struct vn_cs_encoder *enc, const void *val)
18146 {
18147     /* no known/supported struct */
18148     vn_encode_simple_pointer(enc, NULL);
18149 }
18150 
18151 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)18152 vn_encode_VkPhysicalDeviceExternalFenceInfo_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
18153 {
18154     /* skip val->{sType,pNext} */
18155     vn_encode_VkExternalFenceHandleTypeFlagBits(enc, &val->handleType);
18156 }
18157 
18158 static inline void
vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder * enc,const VkPhysicalDeviceExternalFenceInfo * val)18159 vn_encode_VkPhysicalDeviceExternalFenceInfo(struct vn_cs_encoder *enc, const VkPhysicalDeviceExternalFenceInfo *val)
18160 {
18161     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO);
18162     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO });
18163     vn_encode_VkPhysicalDeviceExternalFenceInfo_pnext(enc, val->pNext);
18164     vn_encode_VkPhysicalDeviceExternalFenceInfo_self(enc, val);
18165 }
18166 
18167 /* struct VkExternalFenceProperties chain */
18168 
18169 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext(const void * val)18170 vn_sizeof_VkExternalFenceProperties_pnext(const void *val)
18171 {
18172     /* no known/supported struct */
18173     return vn_sizeof_simple_pointer(NULL);
18174 }
18175 
18176 static inline size_t
vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties * val)18177 vn_sizeof_VkExternalFenceProperties_self(const VkExternalFenceProperties *val)
18178 {
18179     size_t size = 0;
18180     /* skip val->{sType,pNext} */
18181     size += vn_sizeof_VkFlags(&val->exportFromImportedHandleTypes);
18182     size += vn_sizeof_VkFlags(&val->compatibleHandleTypes);
18183     size += vn_sizeof_VkFlags(&val->externalFenceFeatures);
18184     return size;
18185 }
18186 
18187 static inline size_t
vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties * val)18188 vn_sizeof_VkExternalFenceProperties(const VkExternalFenceProperties *val)
18189 {
18190     size_t size = 0;
18191 
18192     size += vn_sizeof_VkStructureType(&val->sType);
18193     size += vn_sizeof_VkExternalFenceProperties_pnext(val->pNext);
18194     size += vn_sizeof_VkExternalFenceProperties_self(val);
18195 
18196     return size;
18197 }
18198 
18199 static inline void
vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder * dec,const void * val)18200 vn_decode_VkExternalFenceProperties_pnext(struct vn_cs_decoder *dec, const void *val)
18201 {
18202     /* no known/supported struct */
18203     if (vn_decode_simple_pointer(dec))
18204         assert(false);
18205 }
18206 
18207 static inline void
vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)18208 vn_decode_VkExternalFenceProperties_self(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
18209 {
18210     /* skip val->{sType,pNext} */
18211     vn_decode_VkFlags(dec, &val->exportFromImportedHandleTypes);
18212     vn_decode_VkFlags(dec, &val->compatibleHandleTypes);
18213     vn_decode_VkFlags(dec, &val->externalFenceFeatures);
18214 }
18215 
18216 static inline void
vn_decode_VkExternalFenceProperties(struct vn_cs_decoder * dec,VkExternalFenceProperties * val)18217 vn_decode_VkExternalFenceProperties(struct vn_cs_decoder *dec, VkExternalFenceProperties *val)
18218 {
18219     VkStructureType stype;
18220     vn_decode_VkStructureType(dec, &stype);
18221     assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
18222 
18223     assert(val->sType == stype);
18224     vn_decode_VkExternalFenceProperties_pnext(dec, val->pNext);
18225     vn_decode_VkExternalFenceProperties_self(dec, val);
18226 }
18227 
18228 static inline size_t
vn_sizeof_VkExternalFenceProperties_pnext_partial(const void * val)18229 vn_sizeof_VkExternalFenceProperties_pnext_partial(const void *val)
18230 {
18231     /* no known/supported struct */
18232     return vn_sizeof_simple_pointer(NULL);
18233 }
18234 
18235 static inline size_t
vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties * val)18236 vn_sizeof_VkExternalFenceProperties_self_partial(const VkExternalFenceProperties *val)
18237 {
18238     size_t size = 0;
18239     /* skip val->{sType,pNext} */
18240     /* skip val->exportFromImportedHandleTypes */
18241     /* skip val->compatibleHandleTypes */
18242     /* skip val->externalFenceFeatures */
18243     return size;
18244 }
18245 
18246 static inline size_t
vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties * val)18247 vn_sizeof_VkExternalFenceProperties_partial(const VkExternalFenceProperties *val)
18248 {
18249     size_t size = 0;
18250 
18251     size += vn_sizeof_VkStructureType(&val->sType);
18252     size += vn_sizeof_VkExternalFenceProperties_pnext_partial(val->pNext);
18253     size += vn_sizeof_VkExternalFenceProperties_self_partial(val);
18254 
18255     return size;
18256 }
18257 
18258 static inline void
vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)18259 vn_encode_VkExternalFenceProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18260 {
18261     /* no known/supported struct */
18262     vn_encode_simple_pointer(enc, NULL);
18263 }
18264 
18265 static inline void
vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)18266 vn_encode_VkExternalFenceProperties_self_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
18267 {
18268     /* skip val->{sType,pNext} */
18269     /* skip val->exportFromImportedHandleTypes */
18270     /* skip val->compatibleHandleTypes */
18271     /* skip val->externalFenceFeatures */
18272 }
18273 
18274 static inline void
vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder * enc,const VkExternalFenceProperties * val)18275 vn_encode_VkExternalFenceProperties_partial(struct vn_cs_encoder *enc, const VkExternalFenceProperties *val)
18276 {
18277     assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
18278     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES });
18279     vn_encode_VkExternalFenceProperties_pnext_partial(enc, val->pNext);
18280     vn_encode_VkExternalFenceProperties_self_partial(enc, val);
18281 }
18282 
18283 /* struct VkPhysicalDeviceGroupProperties chain */
18284 
18285 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void * val)18286 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(const void *val)
18287 {
18288     /* no known/supported struct */
18289     return vn_sizeof_simple_pointer(NULL);
18290 }
18291 
18292 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties * val)18293 vn_sizeof_VkPhysicalDeviceGroupProperties_self(const VkPhysicalDeviceGroupProperties *val)
18294 {
18295     size_t size = 0;
18296     /* skip val->{sType,pNext} */
18297     size += vn_sizeof_uint32_t(&val->physicalDeviceCount);
18298     size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
18299     for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
18300         size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
18301     size += vn_sizeof_VkBool32(&val->subsetAllocation);
18302     return size;
18303 }
18304 
18305 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties * val)18306 vn_sizeof_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties *val)
18307 {
18308     size_t size = 0;
18309 
18310     size += vn_sizeof_VkStructureType(&val->sType);
18311     size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext(val->pNext);
18312     size += vn_sizeof_VkPhysicalDeviceGroupProperties_self(val);
18313 
18314     return size;
18315 }
18316 
18317 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder * dec,const void * val)18318 vn_decode_VkPhysicalDeviceGroupProperties_pnext(struct vn_cs_decoder *dec, const void *val)
18319 {
18320     /* no known/supported struct */
18321     if (vn_decode_simple_pointer(dec))
18322         assert(false);
18323 }
18324 
18325 static inline void
vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)18326 vn_decode_VkPhysicalDeviceGroupProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
18327 {
18328     /* skip val->{sType,pNext} */
18329     vn_decode_uint32_t(dec, &val->physicalDeviceCount);
18330     {
18331         const uint32_t iter_count = vn_decode_array_size(dec, VK_MAX_DEVICE_GROUP_SIZE);
18332         for (uint32_t i = 0; i < iter_count; i++)
18333             vn_decode_VkPhysicalDevice(dec, &val->physicalDevices[i]);
18334     }
18335     vn_decode_VkBool32(dec, &val->subsetAllocation);
18336 }
18337 
18338 static inline void
vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceGroupProperties * val)18339 vn_decode_VkPhysicalDeviceGroupProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceGroupProperties *val)
18340 {
18341     VkStructureType stype;
18342     vn_decode_VkStructureType(dec, &stype);
18343     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
18344 
18345     assert(val->sType == stype);
18346     vn_decode_VkPhysicalDeviceGroupProperties_pnext(dec, val->pNext);
18347     vn_decode_VkPhysicalDeviceGroupProperties_self(dec, val);
18348 }
18349 
18350 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void * val)18351 vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(const void *val)
18352 {
18353     /* no known/supported struct */
18354     return vn_sizeof_simple_pointer(NULL);
18355 }
18356 
18357 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties * val)18358 vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(const VkPhysicalDeviceGroupProperties *val)
18359 {
18360     size_t size = 0;
18361     /* skip val->{sType,pNext} */
18362     /* skip val->physicalDeviceCount */
18363     size += vn_sizeof_array_size(VK_MAX_DEVICE_GROUP_SIZE);
18364     for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
18365         size += vn_sizeof_VkPhysicalDevice(&val->physicalDevices[i]);
18366     /* skip val->subsetAllocation */
18367     return size;
18368 }
18369 
18370 static inline size_t
vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties * val)18371 vn_sizeof_VkPhysicalDeviceGroupProperties_partial(const VkPhysicalDeviceGroupProperties *val)
18372 {
18373     size_t size = 0;
18374 
18375     size += vn_sizeof_VkStructureType(&val->sType);
18376     size += vn_sizeof_VkPhysicalDeviceGroupProperties_pnext_partial(val->pNext);
18377     size += vn_sizeof_VkPhysicalDeviceGroupProperties_self_partial(val);
18378 
18379     return size;
18380 }
18381 
18382 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)18383 vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18384 {
18385     /* no known/supported struct */
18386     vn_encode_simple_pointer(enc, NULL);
18387 }
18388 
18389 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)18390 vn_encode_VkPhysicalDeviceGroupProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
18391 {
18392     /* skip val->{sType,pNext} */
18393     /* skip val->physicalDeviceCount */
18394     vn_encode_array_size(enc, VK_MAX_DEVICE_GROUP_SIZE);
18395     for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
18396         vn_encode_VkPhysicalDevice(enc, &val->physicalDevices[i]);
18397     /* skip val->subsetAllocation */
18398 }
18399 
18400 static inline void
vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceGroupProperties * val)18401 vn_encode_VkPhysicalDeviceGroupProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceGroupProperties *val)
18402 {
18403     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);
18404     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES });
18405     vn_encode_VkPhysicalDeviceGroupProperties_pnext_partial(enc, val->pNext);
18406     vn_encode_VkPhysicalDeviceGroupProperties_self_partial(enc, val);
18407 }
18408 
18409 /* struct VkDeviceQueueInfo2 chain */
18410 
18411 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_pnext(const void * val)18412 vn_sizeof_VkDeviceQueueInfo2_pnext(const void *val)
18413 {
18414     /* no known/supported struct */
18415     return vn_sizeof_simple_pointer(NULL);
18416 }
18417 
18418 static inline size_t
vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 * val)18419 vn_sizeof_VkDeviceQueueInfo2_self(const VkDeviceQueueInfo2 *val)
18420 {
18421     size_t size = 0;
18422     /* skip val->{sType,pNext} */
18423     size += vn_sizeof_VkFlags(&val->flags);
18424     size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
18425     size += vn_sizeof_uint32_t(&val->queueIndex);
18426     return size;
18427 }
18428 
18429 static inline size_t
vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 * val)18430 vn_sizeof_VkDeviceQueueInfo2(const VkDeviceQueueInfo2 *val)
18431 {
18432     size_t size = 0;
18433 
18434     size += vn_sizeof_VkStructureType(&val->sType);
18435     size += vn_sizeof_VkDeviceQueueInfo2_pnext(val->pNext);
18436     size += vn_sizeof_VkDeviceQueueInfo2_self(val);
18437 
18438     return size;
18439 }
18440 
18441 static inline void
vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder * enc,const void * val)18442 vn_encode_VkDeviceQueueInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
18443 {
18444     /* no known/supported struct */
18445     vn_encode_simple_pointer(enc, NULL);
18446 }
18447 
18448 static inline void
vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)18449 vn_encode_VkDeviceQueueInfo2_self(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
18450 {
18451     /* skip val->{sType,pNext} */
18452     vn_encode_VkFlags(enc, &val->flags);
18453     vn_encode_uint32_t(enc, &val->queueFamilyIndex);
18454     vn_encode_uint32_t(enc, &val->queueIndex);
18455 }
18456 
18457 static inline void
vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder * enc,const VkDeviceQueueInfo2 * val)18458 vn_encode_VkDeviceQueueInfo2(struct vn_cs_encoder *enc, const VkDeviceQueueInfo2 *val)
18459 {
18460     assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2);
18461     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 });
18462     vn_encode_VkDeviceQueueInfo2_pnext(enc, val->pNext);
18463     vn_encode_VkDeviceQueueInfo2_self(enc, val);
18464 }
18465 
18466 /* struct VkCalibratedTimestampInfoEXT chain */
18467 
18468 static inline size_t
vn_sizeof_VkCalibratedTimestampInfoEXT_pnext(const void * val)18469 vn_sizeof_VkCalibratedTimestampInfoEXT_pnext(const void *val)
18470 {
18471     /* no known/supported struct */
18472     return vn_sizeof_simple_pointer(NULL);
18473 }
18474 
18475 static inline size_t
vn_sizeof_VkCalibratedTimestampInfoEXT_self(const VkCalibratedTimestampInfoEXT * val)18476 vn_sizeof_VkCalibratedTimestampInfoEXT_self(const VkCalibratedTimestampInfoEXT *val)
18477 {
18478     size_t size = 0;
18479     /* skip val->{sType,pNext} */
18480     size += vn_sizeof_VkTimeDomainEXT(&val->timeDomain);
18481     return size;
18482 }
18483 
18484 static inline size_t
vn_sizeof_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT * val)18485 vn_sizeof_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT *val)
18486 {
18487     size_t size = 0;
18488 
18489     size += vn_sizeof_VkStructureType(&val->sType);
18490     size += vn_sizeof_VkCalibratedTimestampInfoEXT_pnext(val->pNext);
18491     size += vn_sizeof_VkCalibratedTimestampInfoEXT_self(val);
18492 
18493     return size;
18494 }
18495 
18496 static inline void
vn_encode_VkCalibratedTimestampInfoEXT_pnext(struct vn_cs_encoder * enc,const void * val)18497 vn_encode_VkCalibratedTimestampInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
18498 {
18499     /* no known/supported struct */
18500     vn_encode_simple_pointer(enc, NULL);
18501 }
18502 
18503 static inline void
vn_encode_VkCalibratedTimestampInfoEXT_self(struct vn_cs_encoder * enc,const VkCalibratedTimestampInfoEXT * val)18504 vn_encode_VkCalibratedTimestampInfoEXT_self(struct vn_cs_encoder *enc, const VkCalibratedTimestampInfoEXT *val)
18505 {
18506     /* skip val->{sType,pNext} */
18507     vn_encode_VkTimeDomainEXT(enc, &val->timeDomain);
18508 }
18509 
18510 static inline void
vn_encode_VkCalibratedTimestampInfoEXT(struct vn_cs_encoder * enc,const VkCalibratedTimestampInfoEXT * val)18511 vn_encode_VkCalibratedTimestampInfoEXT(struct vn_cs_encoder *enc, const VkCalibratedTimestampInfoEXT *val)
18512 {
18513     assert(val->sType == VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT);
18514     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT });
18515     vn_encode_VkCalibratedTimestampInfoEXT_pnext(enc, val->pNext);
18516     vn_encode_VkCalibratedTimestampInfoEXT_self(enc, val);
18517 }
18518 
18519 /* struct VkPhysicalDeviceToolProperties chain */
18520 
18521 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_pnext(const void * val)18522 vn_sizeof_VkPhysicalDeviceToolProperties_pnext(const void *val)
18523 {
18524     /* no known/supported struct */
18525     return vn_sizeof_simple_pointer(NULL);
18526 }
18527 
18528 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_self(const VkPhysicalDeviceToolProperties * val)18529 vn_sizeof_VkPhysicalDeviceToolProperties_self(const VkPhysicalDeviceToolProperties *val)
18530 {
18531     size_t size = 0;
18532     /* skip val->{sType,pNext} */
18533     size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
18534     size += vn_sizeof_char_array(val->name, VK_MAX_EXTENSION_NAME_SIZE);
18535     size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
18536     size += vn_sizeof_char_array(val->version, VK_MAX_EXTENSION_NAME_SIZE);
18537     size += vn_sizeof_VkFlags(&val->purposes);
18538     size += vn_sizeof_array_size(VK_MAX_DESCRIPTION_SIZE);
18539     size += vn_sizeof_char_array(val->description, VK_MAX_DESCRIPTION_SIZE);
18540     size += vn_sizeof_array_size(VK_MAX_EXTENSION_NAME_SIZE);
18541     size += vn_sizeof_char_array(val->layer, VK_MAX_EXTENSION_NAME_SIZE);
18542     return size;
18543 }
18544 
18545 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties * val)18546 vn_sizeof_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties *val)
18547 {
18548     size_t size = 0;
18549 
18550     size += vn_sizeof_VkStructureType(&val->sType);
18551     size += vn_sizeof_VkPhysicalDeviceToolProperties_pnext(val->pNext);
18552     size += vn_sizeof_VkPhysicalDeviceToolProperties_self(val);
18553 
18554     return size;
18555 }
18556 
18557 static inline void
vn_decode_VkPhysicalDeviceToolProperties_pnext(struct vn_cs_decoder * dec,const void * val)18558 vn_decode_VkPhysicalDeviceToolProperties_pnext(struct vn_cs_decoder *dec, const void *val)
18559 {
18560     /* no known/supported struct */
18561     if (vn_decode_simple_pointer(dec))
18562         assert(false);
18563 }
18564 
18565 static inline void
vn_decode_VkPhysicalDeviceToolProperties_self(struct vn_cs_decoder * dec,VkPhysicalDeviceToolProperties * val)18566 vn_decode_VkPhysicalDeviceToolProperties_self(struct vn_cs_decoder *dec, VkPhysicalDeviceToolProperties *val)
18567 {
18568     /* skip val->{sType,pNext} */
18569     {
18570         const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
18571         vn_decode_char_array(dec, val->name, array_size);
18572     }
18573     {
18574         const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
18575         vn_decode_char_array(dec, val->version, array_size);
18576     }
18577     vn_decode_VkFlags(dec, &val->purposes);
18578     {
18579         const size_t array_size = vn_decode_array_size(dec, VK_MAX_DESCRIPTION_SIZE);
18580         vn_decode_char_array(dec, val->description, array_size);
18581     }
18582     {
18583         const size_t array_size = vn_decode_array_size(dec, VK_MAX_EXTENSION_NAME_SIZE);
18584         vn_decode_char_array(dec, val->layer, array_size);
18585     }
18586 }
18587 
18588 static inline void
vn_decode_VkPhysicalDeviceToolProperties(struct vn_cs_decoder * dec,VkPhysicalDeviceToolProperties * val)18589 vn_decode_VkPhysicalDeviceToolProperties(struct vn_cs_decoder *dec, VkPhysicalDeviceToolProperties *val)
18590 {
18591     VkStructureType stype;
18592     vn_decode_VkStructureType(dec, &stype);
18593     assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES);
18594 
18595     assert(val->sType == stype);
18596     vn_decode_VkPhysicalDeviceToolProperties_pnext(dec, val->pNext);
18597     vn_decode_VkPhysicalDeviceToolProperties_self(dec, val);
18598 }
18599 
18600 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(const void * val)18601 vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(const void *val)
18602 {
18603     /* no known/supported struct */
18604     return vn_sizeof_simple_pointer(NULL);
18605 }
18606 
18607 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(const VkPhysicalDeviceToolProperties * val)18608 vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(const VkPhysicalDeviceToolProperties *val)
18609 {
18610     size_t size = 0;
18611     /* skip val->{sType,pNext} */
18612     /* skip val->name */
18613     /* skip val->version */
18614     /* skip val->purposes */
18615     /* skip val->description */
18616     /* skip val->layer */
18617     return size;
18618 }
18619 
18620 static inline size_t
vn_sizeof_VkPhysicalDeviceToolProperties_partial(const VkPhysicalDeviceToolProperties * val)18621 vn_sizeof_VkPhysicalDeviceToolProperties_partial(const VkPhysicalDeviceToolProperties *val)
18622 {
18623     size_t size = 0;
18624 
18625     size += vn_sizeof_VkStructureType(&val->sType);
18626     size += vn_sizeof_VkPhysicalDeviceToolProperties_pnext_partial(val->pNext);
18627     size += vn_sizeof_VkPhysicalDeviceToolProperties_self_partial(val);
18628 
18629     return size;
18630 }
18631 
18632 static inline void
vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(struct vn_cs_encoder * enc,const void * val)18633 vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(struct vn_cs_encoder *enc, const void *val)
18634 {
18635     /* no known/supported struct */
18636     vn_encode_simple_pointer(enc, NULL);
18637 }
18638 
18639 static inline void
vn_encode_VkPhysicalDeviceToolProperties_self_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceToolProperties * val)18640 vn_encode_VkPhysicalDeviceToolProperties_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceToolProperties *val)
18641 {
18642     /* skip val->{sType,pNext} */
18643     /* skip val->name */
18644     /* skip val->version */
18645     /* skip val->purposes */
18646     /* skip val->description */
18647     /* skip val->layer */
18648 }
18649 
18650 static inline void
vn_encode_VkPhysicalDeviceToolProperties_partial(struct vn_cs_encoder * enc,const VkPhysicalDeviceToolProperties * val)18651 vn_encode_VkPhysicalDeviceToolProperties_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceToolProperties *val)
18652 {
18653     assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES);
18654     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES });
18655     vn_encode_VkPhysicalDeviceToolProperties_pnext_partial(enc, val->pNext);
18656     vn_encode_VkPhysicalDeviceToolProperties_self_partial(enc, val);
18657 }
18658 
vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)18659 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
18660 {
18661     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
18662     const VkFlags cmd_flags = 0;
18663     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
18664 
18665     cmd_size += vn_sizeof_VkInstance(&instance);
18666     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
18667     if (pPhysicalDeviceCount)
18668         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
18669     if (pPhysicalDevices) {
18670         cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
18671         for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
18672             cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
18673     } else {
18674         cmd_size += vn_sizeof_array_size(0);
18675     }
18676 
18677     return cmd_size;
18678 }
18679 
vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)18680 static inline void vn_encode_vkEnumeratePhysicalDevices(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
18681 {
18682     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
18683 
18684     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
18685     vn_encode_VkFlags(enc, &cmd_flags);
18686 
18687     vn_encode_VkInstance(enc, &instance);
18688     if (vn_encode_simple_pointer(enc, pPhysicalDeviceCount))
18689         vn_encode_uint32_t(enc, pPhysicalDeviceCount);
18690     if (pPhysicalDevices) {
18691         vn_encode_array_size(enc, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
18692         for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
18693             vn_encode_VkPhysicalDevice(enc, &pPhysicalDevices[i]);
18694     } else {
18695         vn_encode_array_size(enc, 0);
18696     }
18697 }
18698 
vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)18699 static inline size_t vn_sizeof_vkEnumeratePhysicalDevices_reply(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
18700 {
18701     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT;
18702     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
18703 
18704     VkResult ret;
18705     cmd_size += vn_sizeof_VkResult(&ret);
18706     /* skip instance */
18707     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceCount);
18708     if (pPhysicalDeviceCount)
18709         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceCount);
18710     if (pPhysicalDevices) {
18711         cmd_size += vn_sizeof_array_size((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
18712         for (uint32_t i = 0; i < (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); i++)
18713             cmd_size += vn_sizeof_VkPhysicalDevice(&pPhysicalDevices[i]);
18714     } else {
18715         cmd_size += vn_sizeof_array_size(0);
18716     }
18717 
18718     return cmd_size;
18719 }
18720 
vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)18721 static inline VkResult vn_decode_vkEnumeratePhysicalDevices_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
18722 {
18723     VkCommandTypeEXT command_type;
18724     vn_decode_VkCommandTypeEXT(dec, &command_type);
18725     assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT);
18726 
18727     VkResult ret;
18728     vn_decode_VkResult(dec, &ret);
18729     /* skip instance */
18730     if (vn_decode_simple_pointer(dec)) {
18731         vn_decode_uint32_t(dec, pPhysicalDeviceCount);
18732     } else {
18733         pPhysicalDeviceCount = NULL;
18734     }
18735     if (vn_peek_array_size(dec)) {
18736         const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0));
18737         for (uint32_t i = 0; i < iter_count; i++)
18738             vn_decode_VkPhysicalDevice(dec, &pPhysicalDevices[i]);
18739     } else {
18740         vn_decode_array_size_unchecked(dec);
18741         pPhysicalDevices = NULL;
18742     }
18743 
18744     return ret;
18745 }
18746 
vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)18747 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
18748 {
18749     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
18750     const VkFlags cmd_flags = 0;
18751     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
18752 
18753     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
18754     cmd_size += vn_sizeof_simple_pointer(pProperties);
18755     if (pProperties)
18756         cmd_size += vn_sizeof_VkPhysicalDeviceProperties_partial(pProperties);
18757 
18758     return cmd_size;
18759 }
18760 
vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)18761 static inline void vn_encode_vkGetPhysicalDeviceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
18762 {
18763     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
18764 
18765     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
18766     vn_encode_VkFlags(enc, &cmd_flags);
18767 
18768     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
18769     if (vn_encode_simple_pointer(enc, pProperties))
18770         vn_encode_VkPhysicalDeviceProperties_partial(enc, pProperties);
18771 }
18772 
vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)18773 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
18774 {
18775     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT;
18776     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
18777 
18778     /* skip physicalDevice */
18779     cmd_size += vn_sizeof_simple_pointer(pProperties);
18780     if (pProperties)
18781         cmd_size += vn_sizeof_VkPhysicalDeviceProperties(pProperties);
18782 
18783     return cmd_size;
18784 }
18785 
vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)18786 static inline void vn_decode_vkGetPhysicalDeviceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
18787 {
18788     VkCommandTypeEXT command_type;
18789     vn_decode_VkCommandTypeEXT(dec, &command_type);
18790     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties_EXT);
18791 
18792     /* skip physicalDevice */
18793     if (vn_decode_simple_pointer(dec)) {
18794         vn_decode_VkPhysicalDeviceProperties(dec, pProperties);
18795     } else {
18796         pProperties = NULL;
18797     }
18798 }
18799 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)18800 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
18801 {
18802     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
18803     const VkFlags cmd_flags = 0;
18804     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
18805 
18806     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
18807     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
18808     if (pQueueFamilyPropertyCount)
18809         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
18810     if (pQueueFamilyProperties) {
18811         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
18812         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
18813             cmd_size += vn_sizeof_VkQueueFamilyProperties_partial(&pQueueFamilyProperties[i]);
18814     } else {
18815         cmd_size += vn_sizeof_array_size(0);
18816     }
18817 
18818     return cmd_size;
18819 }
18820 
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)18821 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
18822 {
18823     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
18824 
18825     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
18826     vn_encode_VkFlags(enc, &cmd_flags);
18827 
18828     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
18829     if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
18830         vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
18831     if (pQueueFamilyProperties) {
18832         vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
18833         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
18834             vn_encode_VkQueueFamilyProperties_partial(enc, &pQueueFamilyProperties[i]);
18835     } else {
18836         vn_encode_array_size(enc, 0);
18837     }
18838 }
18839 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)18840 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
18841 {
18842     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT;
18843     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
18844 
18845     /* skip physicalDevice */
18846     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
18847     if (pQueueFamilyPropertyCount)
18848         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
18849     if (pQueueFamilyProperties) {
18850         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
18851         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
18852             cmd_size += vn_sizeof_VkQueueFamilyProperties(&pQueueFamilyProperties[i]);
18853     } else {
18854         cmd_size += vn_sizeof_array_size(0);
18855     }
18856 
18857     return cmd_size;
18858 }
18859 
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)18860 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
18861 {
18862     VkCommandTypeEXT command_type;
18863     vn_decode_VkCommandTypeEXT(dec, &command_type);
18864     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties_EXT);
18865 
18866     /* skip physicalDevice */
18867     if (vn_decode_simple_pointer(dec)) {
18868         vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
18869     } else {
18870         pQueueFamilyPropertyCount = NULL;
18871     }
18872     if (vn_peek_array_size(dec)) {
18873         const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
18874         for (uint32_t i = 0; i < iter_count; i++)
18875             vn_decode_VkQueueFamilyProperties(dec, &pQueueFamilyProperties[i]);
18876     } else {
18877         vn_decode_array_size_unchecked(dec);
18878         pQueueFamilyProperties = NULL;
18879     }
18880 }
18881 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)18882 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
18883 {
18884     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
18885     const VkFlags cmd_flags = 0;
18886     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
18887 
18888     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
18889     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
18890     if (pMemoryProperties)
18891         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties_partial(pMemoryProperties);
18892 
18893     return cmd_size;
18894 }
18895 
vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)18896 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
18897 {
18898     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
18899 
18900     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
18901     vn_encode_VkFlags(enc, &cmd_flags);
18902 
18903     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
18904     if (vn_encode_simple_pointer(enc, pMemoryProperties))
18905         vn_encode_VkPhysicalDeviceMemoryProperties_partial(enc, pMemoryProperties);
18906 }
18907 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)18908 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
18909 {
18910     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT;
18911     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
18912 
18913     /* skip physicalDevice */
18914     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
18915     if (pMemoryProperties)
18916         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties(pMemoryProperties);
18917 
18918     return cmd_size;
18919 }
18920 
vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)18921 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
18922 {
18923     VkCommandTypeEXT command_type;
18924     vn_decode_VkCommandTypeEXT(dec, &command_type);
18925     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties_EXT);
18926 
18927     /* skip physicalDevice */
18928     if (vn_decode_simple_pointer(dec)) {
18929         vn_decode_VkPhysicalDeviceMemoryProperties(dec, pMemoryProperties);
18930     } else {
18931         pMemoryProperties = NULL;
18932     }
18933 }
18934 
vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)18935 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
18936 {
18937     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
18938     const VkFlags cmd_flags = 0;
18939     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
18940 
18941     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
18942     cmd_size += vn_sizeof_simple_pointer(pFeatures);
18943     if (pFeatures)
18944         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures_partial(pFeatures);
18945 
18946     return cmd_size;
18947 }
18948 
vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)18949 static inline void vn_encode_vkGetPhysicalDeviceFeatures(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
18950 {
18951     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
18952 
18953     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
18954     vn_encode_VkFlags(enc, &cmd_flags);
18955 
18956     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
18957     if (vn_encode_simple_pointer(enc, pFeatures))
18958         vn_encode_VkPhysicalDeviceFeatures_partial(enc, pFeatures);
18959 }
18960 
vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)18961 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
18962 {
18963     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT;
18964     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
18965 
18966     /* skip physicalDevice */
18967     cmd_size += vn_sizeof_simple_pointer(pFeatures);
18968     if (pFeatures)
18969         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures(pFeatures);
18970 
18971     return cmd_size;
18972 }
18973 
vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)18974 static inline void vn_decode_vkGetPhysicalDeviceFeatures_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
18975 {
18976     VkCommandTypeEXT command_type;
18977     vn_decode_VkCommandTypeEXT(dec, &command_type);
18978     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures_EXT);
18979 
18980     /* skip physicalDevice */
18981     if (vn_decode_simple_pointer(dec)) {
18982         vn_decode_VkPhysicalDeviceFeatures(dec, pFeatures);
18983     } else {
18984         pFeatures = NULL;
18985     }
18986 }
18987 
vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)18988 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
18989 {
18990     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
18991     const VkFlags cmd_flags = 0;
18992     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
18993 
18994     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
18995     cmd_size += vn_sizeof_VkFormat(&format);
18996     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
18997     if (pFormatProperties)
18998         cmd_size += vn_sizeof_VkFormatProperties_partial(pFormatProperties);
18999 
19000     return cmd_size;
19001 }
19002 
vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)19003 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
19004 {
19005     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
19006 
19007     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19008     vn_encode_VkFlags(enc, &cmd_flags);
19009 
19010     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19011     vn_encode_VkFormat(enc, &format);
19012     if (vn_encode_simple_pointer(enc, pFormatProperties))
19013         vn_encode_VkFormatProperties_partial(enc, pFormatProperties);
19014 }
19015 
vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)19016 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
19017 {
19018     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT;
19019     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19020 
19021     /* skip physicalDevice */
19022     /* skip format */
19023     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
19024     if (pFormatProperties)
19025         cmd_size += vn_sizeof_VkFormatProperties(pFormatProperties);
19026 
19027     return cmd_size;
19028 }
19029 
vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)19030 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
19031 {
19032     VkCommandTypeEXT command_type;
19033     vn_decode_VkCommandTypeEXT(dec, &command_type);
19034     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties_EXT);
19035 
19036     /* skip physicalDevice */
19037     /* skip format */
19038     if (vn_decode_simple_pointer(dec)) {
19039         vn_decode_VkFormatProperties(dec, pFormatProperties);
19040     } else {
19041         pFormatProperties = NULL;
19042     }
19043 }
19044 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)19045 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
19046 {
19047     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
19048     const VkFlags cmd_flags = 0;
19049     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19050 
19051     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19052     cmd_size += vn_sizeof_VkFormat(&format);
19053     cmd_size += vn_sizeof_VkImageType(&type);
19054     cmd_size += vn_sizeof_VkImageTiling(&tiling);
19055     cmd_size += vn_sizeof_VkFlags(&usage);
19056     cmd_size += vn_sizeof_VkFlags(&flags);
19057     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
19058     if (pImageFormatProperties)
19059         cmd_size += vn_sizeof_VkImageFormatProperties_partial(pImageFormatProperties);
19060 
19061     return cmd_size;
19062 }
19063 
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)19064 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)
19065 {
19066     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
19067 
19068     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19069     vn_encode_VkFlags(enc, &cmd_flags);
19070 
19071     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19072     vn_encode_VkFormat(enc, &format);
19073     vn_encode_VkImageType(enc, &type);
19074     vn_encode_VkImageTiling(enc, &tiling);
19075     vn_encode_VkFlags(enc, &usage);
19076     vn_encode_VkFlags(enc, &flags);
19077     if (vn_encode_simple_pointer(enc, pImageFormatProperties))
19078         vn_encode_VkImageFormatProperties_partial(enc, pImageFormatProperties);
19079 }
19080 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)19081 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
19082 {
19083     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT;
19084     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19085 
19086     VkResult ret;
19087     cmd_size += vn_sizeof_VkResult(&ret);
19088     /* skip physicalDevice */
19089     /* skip format */
19090     /* skip type */
19091     /* skip tiling */
19092     /* skip usage */
19093     /* skip flags */
19094     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
19095     if (pImageFormatProperties)
19096         cmd_size += vn_sizeof_VkImageFormatProperties(pImageFormatProperties);
19097 
19098     return cmd_size;
19099 }
19100 
vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)19101 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)
19102 {
19103     VkCommandTypeEXT command_type;
19104     vn_decode_VkCommandTypeEXT(dec, &command_type);
19105     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties_EXT);
19106 
19107     VkResult ret;
19108     vn_decode_VkResult(dec, &ret);
19109     /* skip physicalDevice */
19110     /* skip format */
19111     /* skip type */
19112     /* skip tiling */
19113     /* skip usage */
19114     /* skip flags */
19115     if (vn_decode_simple_pointer(dec)) {
19116         vn_decode_VkImageFormatProperties(dec, pImageFormatProperties);
19117     } else {
19118         pImageFormatProperties = NULL;
19119     }
19120 
19121     return ret;
19122 }
19123 
vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)19124 static inline size_t vn_sizeof_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
19125 {
19126     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
19127     const VkFlags cmd_flags = 0;
19128     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19129 
19130     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19131     cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
19132     if (pCreateInfo)
19133         cmd_size += vn_sizeof_VkDeviceCreateInfo(pCreateInfo);
19134     cmd_size += vn_sizeof_simple_pointer(pAllocator);
19135     if (pAllocator)
19136         assert(false);
19137     cmd_size += vn_sizeof_simple_pointer(pDevice);
19138     if (pDevice)
19139         cmd_size += vn_sizeof_VkDevice(pDevice);
19140 
19141     return cmd_size;
19142 }
19143 
vn_encode_vkCreateDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)19144 static inline void vn_encode_vkCreateDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
19145 {
19146     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
19147 
19148     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19149     vn_encode_VkFlags(enc, &cmd_flags);
19150 
19151     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19152     if (vn_encode_simple_pointer(enc, pCreateInfo))
19153         vn_encode_VkDeviceCreateInfo(enc, pCreateInfo);
19154     if (vn_encode_simple_pointer(enc, pAllocator))
19155         assert(false);
19156     if (vn_encode_simple_pointer(enc, pDevice))
19157         vn_encode_VkDevice(enc, pDevice);
19158 }
19159 
vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)19160 static inline size_t vn_sizeof_vkCreateDevice_reply(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
19161 {
19162     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDevice_EXT;
19163     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19164 
19165     VkResult ret;
19166     cmd_size += vn_sizeof_VkResult(&ret);
19167     /* skip physicalDevice */
19168     /* skip pCreateInfo */
19169     /* skip pAllocator */
19170     cmd_size += vn_sizeof_simple_pointer(pDevice);
19171     if (pDevice)
19172         cmd_size += vn_sizeof_VkDevice(pDevice);
19173 
19174     return cmd_size;
19175 }
19176 
vn_decode_vkCreateDevice_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)19177 static inline VkResult vn_decode_vkCreateDevice_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
19178 {
19179     VkCommandTypeEXT command_type;
19180     vn_decode_VkCommandTypeEXT(dec, &command_type);
19181     assert(command_type == VK_COMMAND_TYPE_vkCreateDevice_EXT);
19182 
19183     VkResult ret;
19184     vn_decode_VkResult(dec, &ret);
19185     /* skip physicalDevice */
19186     /* skip pCreateInfo */
19187     /* skip pAllocator */
19188     if (vn_decode_simple_pointer(dec)) {
19189         vn_decode_VkDevice(dec, pDevice);
19190     } else {
19191         pDevice = NULL;
19192     }
19193 
19194     return ret;
19195 }
19196 
vn_sizeof_vkDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)19197 static inline size_t vn_sizeof_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
19198 {
19199     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
19200     const VkFlags cmd_flags = 0;
19201     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19202 
19203     cmd_size += vn_sizeof_VkDevice(&device);
19204     cmd_size += vn_sizeof_simple_pointer(pAllocator);
19205     if (pAllocator)
19206         assert(false);
19207 
19208     return cmd_size;
19209 }
19210 
vn_encode_vkDestroyDevice(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator)19211 static inline void vn_encode_vkDestroyDevice(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator)
19212 {
19213     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
19214 
19215     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19216     vn_encode_VkFlags(enc, &cmd_flags);
19217 
19218     vn_encode_VkDevice(enc, &device);
19219     if (vn_encode_simple_pointer(enc, pAllocator))
19220         assert(false);
19221 }
19222 
vn_sizeof_vkDestroyDevice_reply(VkDevice device,const VkAllocationCallbacks * pAllocator)19223 static inline size_t vn_sizeof_vkDestroyDevice_reply(VkDevice device, const VkAllocationCallbacks* pAllocator)
19224 {
19225     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDevice_EXT;
19226     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19227 
19228     /* skip device */
19229     /* skip pAllocator */
19230 
19231     return cmd_size;
19232 }
19233 
vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder * dec,VkDevice device,const VkAllocationCallbacks * pAllocator)19234 static inline void vn_decode_vkDestroyDevice_reply(struct vn_cs_decoder *dec, VkDevice device, const VkAllocationCallbacks* pAllocator)
19235 {
19236     VkCommandTypeEXT command_type;
19237     vn_decode_VkCommandTypeEXT(dec, &command_type);
19238     assert(command_type == VK_COMMAND_TYPE_vkDestroyDevice_EXT);
19239 
19240     /* skip device */
19241     /* skip pAllocator */
19242 }
19243 
vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)19244 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
19245 {
19246     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
19247     const VkFlags cmd_flags = 0;
19248     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19249 
19250     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19251     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
19252     if (pPropertyCount)
19253         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
19254     if (pProperties) {
19255         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
19256         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19257             cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
19258     } else {
19259         cmd_size += vn_sizeof_array_size(0);
19260     }
19261 
19262     return cmd_size;
19263 }
19264 
vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)19265 static inline void vn_encode_vkEnumerateDeviceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
19266 {
19267     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
19268 
19269     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19270     vn_encode_VkFlags(enc, &cmd_flags);
19271 
19272     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19273     if (vn_encode_simple_pointer(enc, pPropertyCount))
19274         vn_encode_uint32_t(enc, pPropertyCount);
19275     if (pProperties) {
19276         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
19277         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19278             vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
19279     } else {
19280         vn_encode_array_size(enc, 0);
19281     }
19282 }
19283 
vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)19284 static inline size_t vn_sizeof_vkEnumerateDeviceLayerProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
19285 {
19286     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT;
19287     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19288 
19289     VkResult ret;
19290     cmd_size += vn_sizeof_VkResult(&ret);
19291     /* skip physicalDevice */
19292     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
19293     if (pPropertyCount)
19294         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
19295     if (pProperties) {
19296         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
19297         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19298             cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
19299     } else {
19300         cmd_size += vn_sizeof_array_size(0);
19301     }
19302 
19303     return cmd_size;
19304 }
19305 
vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)19306 static inline VkResult vn_decode_vkEnumerateDeviceLayerProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
19307 {
19308     VkCommandTypeEXT command_type;
19309     vn_decode_VkCommandTypeEXT(dec, &command_type);
19310     assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceLayerProperties_EXT);
19311 
19312     VkResult ret;
19313     vn_decode_VkResult(dec, &ret);
19314     /* skip physicalDevice */
19315     if (vn_decode_simple_pointer(dec)) {
19316         vn_decode_uint32_t(dec, pPropertyCount);
19317     } else {
19318         pPropertyCount = NULL;
19319     }
19320     if (vn_peek_array_size(dec)) {
19321         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
19322         for (uint32_t i = 0; i < iter_count; i++)
19323             vn_decode_VkLayerProperties(dec, &pProperties[i]);
19324     } else {
19325         vn_decode_array_size_unchecked(dec);
19326         pProperties = NULL;
19327     }
19328 
19329     return ret;
19330 }
19331 
vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)19332 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
19333 {
19334     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
19335     const VkFlags cmd_flags = 0;
19336     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19337 
19338     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19339     if (pLayerName) {
19340         const size_t string_size = strlen(pLayerName) + 1;
19341         cmd_size += vn_sizeof_array_size(string_size);
19342         cmd_size += vn_sizeof_char_array(pLayerName, string_size);
19343     } else {
19344         cmd_size += vn_sizeof_array_size(0);
19345     }
19346     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
19347     if (pPropertyCount)
19348         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
19349     if (pProperties) {
19350         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
19351         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19352             cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
19353     } else {
19354         cmd_size += vn_sizeof_array_size(0);
19355     }
19356 
19357     return cmd_size;
19358 }
19359 
vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)19360 static inline void vn_encode_vkEnumerateDeviceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
19361 {
19362     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
19363 
19364     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19365     vn_encode_VkFlags(enc, &cmd_flags);
19366 
19367     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19368     if (pLayerName) {
19369         const size_t string_size = strlen(pLayerName) + 1;
19370         vn_encode_array_size(enc, string_size);
19371         vn_encode_char_array(enc, pLayerName, string_size);
19372     } else {
19373         vn_encode_array_size(enc, 0);
19374     }
19375     if (vn_encode_simple_pointer(enc, pPropertyCount))
19376         vn_encode_uint32_t(enc, pPropertyCount);
19377     if (pProperties) {
19378         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
19379         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19380             vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
19381     } else {
19382         vn_encode_array_size(enc, 0);
19383     }
19384 }
19385 
vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)19386 static inline size_t vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
19387 {
19388     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT;
19389     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19390 
19391     VkResult ret;
19392     cmd_size += vn_sizeof_VkResult(&ret);
19393     /* skip physicalDevice */
19394     /* skip pLayerName */
19395     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
19396     if (pPropertyCount)
19397         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
19398     if (pProperties) {
19399         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
19400         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19401             cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
19402     } else {
19403         cmd_size += vn_sizeof_array_size(0);
19404     }
19405 
19406     return cmd_size;
19407 }
19408 
vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)19409 static inline VkResult vn_decode_vkEnumerateDeviceExtensionProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
19410 {
19411     VkCommandTypeEXT command_type;
19412     vn_decode_VkCommandTypeEXT(dec, &command_type);
19413     assert(command_type == VK_COMMAND_TYPE_vkEnumerateDeviceExtensionProperties_EXT);
19414 
19415     VkResult ret;
19416     vn_decode_VkResult(dec, &ret);
19417     /* skip physicalDevice */
19418     /* skip pLayerName */
19419     if (vn_decode_simple_pointer(dec)) {
19420         vn_decode_uint32_t(dec, pPropertyCount);
19421     } else {
19422         pPropertyCount = NULL;
19423     }
19424     if (vn_peek_array_size(dec)) {
19425         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
19426         for (uint32_t i = 0; i < iter_count; i++)
19427             vn_decode_VkExtensionProperties(dec, &pProperties[i]);
19428     } else {
19429         vn_decode_array_size_unchecked(dec);
19430         pProperties = NULL;
19431     }
19432 
19433     return ret;
19434 }
19435 
vn_sizeof_vkGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)19436 static inline size_t vn_sizeof_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
19437 {
19438     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
19439     const VkFlags cmd_flags = 0;
19440     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19441 
19442     cmd_size += vn_sizeof_VkDevice(&device);
19443     cmd_size += vn_sizeof_uint32_t(&queueFamilyIndex);
19444     cmd_size += vn_sizeof_uint32_t(&queueIndex);
19445     cmd_size += vn_sizeof_simple_pointer(pQueue);
19446     if (pQueue)
19447         cmd_size += vn_sizeof_VkQueue(pQueue);
19448 
19449     return cmd_size;
19450 }
19451 
vn_encode_vkGetDeviceQueue(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)19452 static inline void vn_encode_vkGetDeviceQueue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
19453 {
19454     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
19455 
19456     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19457     vn_encode_VkFlags(enc, &cmd_flags);
19458 
19459     vn_encode_VkDevice(enc, &device);
19460     vn_encode_uint32_t(enc, &queueFamilyIndex);
19461     vn_encode_uint32_t(enc, &queueIndex);
19462     if (vn_encode_simple_pointer(enc, pQueue))
19463         vn_encode_VkQueue(enc, pQueue);
19464 }
19465 
vn_sizeof_vkGetDeviceQueue_reply(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)19466 static inline size_t vn_sizeof_vkGetDeviceQueue_reply(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
19467 {
19468     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue_EXT;
19469     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19470 
19471     /* skip device */
19472     /* skip queueFamilyIndex */
19473     /* skip queueIndex */
19474     cmd_size += vn_sizeof_simple_pointer(pQueue);
19475     if (pQueue)
19476         cmd_size += vn_sizeof_VkQueue(pQueue);
19477 
19478     return cmd_size;
19479 }
19480 
vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)19481 static inline void vn_decode_vkGetDeviceQueue_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
19482 {
19483     VkCommandTypeEXT command_type;
19484     vn_decode_VkCommandTypeEXT(dec, &command_type);
19485     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue_EXT);
19486 
19487     /* skip device */
19488     /* skip queueFamilyIndex */
19489     /* skip queueIndex */
19490     if (vn_decode_simple_pointer(dec)) {
19491         vn_decode_VkQueue(dec, pQueue);
19492     } else {
19493         pQueue = NULL;
19494     }
19495 }
19496 
vn_sizeof_vkDeviceWaitIdle(VkDevice device)19497 static inline size_t vn_sizeof_vkDeviceWaitIdle(VkDevice device)
19498 {
19499     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
19500     const VkFlags cmd_flags = 0;
19501     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19502 
19503     cmd_size += vn_sizeof_VkDevice(&device);
19504 
19505     return cmd_size;
19506 }
19507 
vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device)19508 static inline void vn_encode_vkDeviceWaitIdle(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device)
19509 {
19510     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
19511 
19512     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19513     vn_encode_VkFlags(enc, &cmd_flags);
19514 
19515     vn_encode_VkDevice(enc, &device);
19516 }
19517 
vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)19518 static inline size_t vn_sizeof_vkDeviceWaitIdle_reply(VkDevice device)
19519 {
19520     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT;
19521     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19522 
19523     VkResult ret;
19524     cmd_size += vn_sizeof_VkResult(&ret);
19525     /* skip device */
19526 
19527     return cmd_size;
19528 }
19529 
vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder * dec,VkDevice device)19530 static inline VkResult vn_decode_vkDeviceWaitIdle_reply(struct vn_cs_decoder *dec, VkDevice device)
19531 {
19532     VkCommandTypeEXT command_type;
19533     vn_decode_VkCommandTypeEXT(dec, &command_type);
19534     assert(command_type == VK_COMMAND_TYPE_vkDeviceWaitIdle_EXT);
19535 
19536     VkResult ret;
19537     vn_decode_VkResult(dec, &ret);
19538     /* skip device */
19539 
19540     return ret;
19541 }
19542 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)19543 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
19544 {
19545     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
19546     const VkFlags cmd_flags = 0;
19547     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19548 
19549     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19550     cmd_size += vn_sizeof_VkFormat(&format);
19551     cmd_size += vn_sizeof_VkImageType(&type);
19552     cmd_size += vn_sizeof_VkSampleCountFlagBits(&samples);
19553     cmd_size += vn_sizeof_VkFlags(&usage);
19554     cmd_size += vn_sizeof_VkImageTiling(&tiling);
19555     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
19556     if (pPropertyCount)
19557         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
19558     if (pProperties) {
19559         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
19560         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19561             cmd_size += vn_sizeof_VkSparseImageFormatProperties_partial(&pProperties[i]);
19562     } else {
19563         cmd_size += vn_sizeof_array_size(0);
19564     }
19565 
19566     return cmd_size;
19567 }
19568 
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)19569 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)
19570 {
19571     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
19572 
19573     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19574     vn_encode_VkFlags(enc, &cmd_flags);
19575 
19576     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19577     vn_encode_VkFormat(enc, &format);
19578     vn_encode_VkImageType(enc, &type);
19579     vn_encode_VkSampleCountFlagBits(enc, &samples);
19580     vn_encode_VkFlags(enc, &usage);
19581     vn_encode_VkImageTiling(enc, &tiling);
19582     if (vn_encode_simple_pointer(enc, pPropertyCount))
19583         vn_encode_uint32_t(enc, pPropertyCount);
19584     if (pProperties) {
19585         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
19586         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19587             vn_encode_VkSparseImageFormatProperties_partial(enc, &pProperties[i]);
19588     } else {
19589         vn_encode_array_size(enc, 0);
19590     }
19591 }
19592 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)19593 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)
19594 {
19595     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT;
19596     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19597 
19598     /* skip physicalDevice */
19599     /* skip format */
19600     /* skip type */
19601     /* skip samples */
19602     /* skip usage */
19603     /* skip tiling */
19604     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
19605     if (pPropertyCount)
19606         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
19607     if (pProperties) {
19608         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
19609         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
19610             cmd_size += vn_sizeof_VkSparseImageFormatProperties(&pProperties[i]);
19611     } else {
19612         cmd_size += vn_sizeof_array_size(0);
19613     }
19614 
19615     return cmd_size;
19616 }
19617 
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)19618 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)
19619 {
19620     VkCommandTypeEXT command_type;
19621     vn_decode_VkCommandTypeEXT(dec, &command_type);
19622     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties_EXT);
19623 
19624     /* skip physicalDevice */
19625     /* skip format */
19626     /* skip type */
19627     /* skip samples */
19628     /* skip usage */
19629     /* skip tiling */
19630     if (vn_decode_simple_pointer(dec)) {
19631         vn_decode_uint32_t(dec, pPropertyCount);
19632     } else {
19633         pPropertyCount = NULL;
19634     }
19635     if (vn_peek_array_size(dec)) {
19636         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
19637         for (uint32_t i = 0; i < iter_count; i++)
19638             vn_decode_VkSparseImageFormatProperties(dec, &pProperties[i]);
19639     } else {
19640         vn_decode_array_size_unchecked(dec);
19641         pProperties = NULL;
19642     }
19643 }
19644 
vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)19645 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
19646 {
19647     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
19648     const VkFlags cmd_flags = 0;
19649     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19650 
19651     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19652     cmd_size += vn_sizeof_simple_pointer(pFeatures);
19653     if (pFeatures)
19654         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2_partial(pFeatures);
19655 
19656     return cmd_size;
19657 }
19658 
vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)19659 static inline void vn_encode_vkGetPhysicalDeviceFeatures2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
19660 {
19661     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
19662 
19663     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19664     vn_encode_VkFlags(enc, &cmd_flags);
19665 
19666     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19667     if (vn_encode_simple_pointer(enc, pFeatures))
19668         vn_encode_VkPhysicalDeviceFeatures2_partial(enc, pFeatures);
19669 }
19670 
vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)19671 static inline size_t vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
19672 {
19673     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT;
19674     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19675 
19676     /* skip physicalDevice */
19677     cmd_size += vn_sizeof_simple_pointer(pFeatures);
19678     if (pFeatures)
19679         cmd_size += vn_sizeof_VkPhysicalDeviceFeatures2(pFeatures);
19680 
19681     return cmd_size;
19682 }
19683 
vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)19684 static inline void vn_decode_vkGetPhysicalDeviceFeatures2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
19685 {
19686     VkCommandTypeEXT command_type;
19687     vn_decode_VkCommandTypeEXT(dec, &command_type);
19688     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFeatures2_EXT);
19689 
19690     /* skip physicalDevice */
19691     if (vn_decode_simple_pointer(dec)) {
19692         vn_decode_VkPhysicalDeviceFeatures2(dec, pFeatures);
19693     } else {
19694         pFeatures = NULL;
19695     }
19696 }
19697 
vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)19698 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
19699 {
19700     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
19701     const VkFlags cmd_flags = 0;
19702     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19703 
19704     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19705     cmd_size += vn_sizeof_simple_pointer(pProperties);
19706     if (pProperties)
19707         cmd_size += vn_sizeof_VkPhysicalDeviceProperties2_partial(pProperties);
19708 
19709     return cmd_size;
19710 }
19711 
vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)19712 static inline void vn_encode_vkGetPhysicalDeviceProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
19713 {
19714     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
19715 
19716     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19717     vn_encode_VkFlags(enc, &cmd_flags);
19718 
19719     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19720     if (vn_encode_simple_pointer(enc, pProperties))
19721         vn_encode_VkPhysicalDeviceProperties2_partial(enc, pProperties);
19722 }
19723 
vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)19724 static inline size_t vn_sizeof_vkGetPhysicalDeviceProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
19725 {
19726     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT;
19727     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19728 
19729     /* skip physicalDevice */
19730     cmd_size += vn_sizeof_simple_pointer(pProperties);
19731     if (pProperties)
19732         cmd_size += vn_sizeof_VkPhysicalDeviceProperties2(pProperties);
19733 
19734     return cmd_size;
19735 }
19736 
vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)19737 static inline void vn_decode_vkGetPhysicalDeviceProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
19738 {
19739     VkCommandTypeEXT command_type;
19740     vn_decode_VkCommandTypeEXT(dec, &command_type);
19741     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceProperties2_EXT);
19742 
19743     /* skip physicalDevice */
19744     if (vn_decode_simple_pointer(dec)) {
19745         vn_decode_VkPhysicalDeviceProperties2(dec, pProperties);
19746     } else {
19747         pProperties = NULL;
19748     }
19749 }
19750 
vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)19751 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
19752 {
19753     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
19754     const VkFlags cmd_flags = 0;
19755     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19756 
19757     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19758     cmd_size += vn_sizeof_VkFormat(&format);
19759     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
19760     if (pFormatProperties)
19761         cmd_size += vn_sizeof_VkFormatProperties2_partial(pFormatProperties);
19762 
19763     return cmd_size;
19764 }
19765 
vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)19766 static inline void vn_encode_vkGetPhysicalDeviceFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
19767 {
19768     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
19769 
19770     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19771     vn_encode_VkFlags(enc, &cmd_flags);
19772 
19773     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19774     vn_encode_VkFormat(enc, &format);
19775     if (vn_encode_simple_pointer(enc, pFormatProperties))
19776         vn_encode_VkFormatProperties2_partial(enc, pFormatProperties);
19777 }
19778 
vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)19779 static inline size_t vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
19780 {
19781     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT;
19782     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19783 
19784     /* skip physicalDevice */
19785     /* skip format */
19786     cmd_size += vn_sizeof_simple_pointer(pFormatProperties);
19787     if (pFormatProperties)
19788         cmd_size += vn_sizeof_VkFormatProperties2(pFormatProperties);
19789 
19790     return cmd_size;
19791 }
19792 
vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)19793 static inline void vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
19794 {
19795     VkCommandTypeEXT command_type;
19796     vn_decode_VkCommandTypeEXT(dec, &command_type);
19797     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceFormatProperties2_EXT);
19798 
19799     /* skip physicalDevice */
19800     /* skip format */
19801     if (vn_decode_simple_pointer(dec)) {
19802         vn_decode_VkFormatProperties2(dec, pFormatProperties);
19803     } else {
19804         pFormatProperties = NULL;
19805     }
19806 }
19807 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)19808 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
19809 {
19810     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
19811     const VkFlags cmd_flags = 0;
19812     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19813 
19814     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19815     cmd_size += vn_sizeof_simple_pointer(pImageFormatInfo);
19816     if (pImageFormatInfo)
19817         cmd_size += vn_sizeof_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
19818     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
19819     if (pImageFormatProperties)
19820         cmd_size += vn_sizeof_VkImageFormatProperties2_partial(pImageFormatProperties);
19821 
19822     return cmd_size;
19823 }
19824 
vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)19825 static inline void vn_encode_vkGetPhysicalDeviceImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
19826 {
19827     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
19828 
19829     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19830     vn_encode_VkFlags(enc, &cmd_flags);
19831 
19832     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19833     if (vn_encode_simple_pointer(enc, pImageFormatInfo))
19834         vn_encode_VkPhysicalDeviceImageFormatInfo2(enc, pImageFormatInfo);
19835     if (vn_encode_simple_pointer(enc, pImageFormatProperties))
19836         vn_encode_VkImageFormatProperties2_partial(enc, pImageFormatProperties);
19837 }
19838 
vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)19839 static inline size_t vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
19840 {
19841     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT;
19842     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19843 
19844     VkResult ret;
19845     cmd_size += vn_sizeof_VkResult(&ret);
19846     /* skip physicalDevice */
19847     /* skip pImageFormatInfo */
19848     cmd_size += vn_sizeof_simple_pointer(pImageFormatProperties);
19849     if (pImageFormatProperties)
19850         cmd_size += vn_sizeof_VkImageFormatProperties2(pImageFormatProperties);
19851 
19852     return cmd_size;
19853 }
19854 
vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)19855 static inline VkResult vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
19856 {
19857     VkCommandTypeEXT command_type;
19858     vn_decode_VkCommandTypeEXT(dec, &command_type);
19859     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceImageFormatProperties2_EXT);
19860 
19861     VkResult ret;
19862     vn_decode_VkResult(dec, &ret);
19863     /* skip physicalDevice */
19864     /* skip pImageFormatInfo */
19865     if (vn_decode_simple_pointer(dec)) {
19866         vn_decode_VkImageFormatProperties2(dec, pImageFormatProperties);
19867     } else {
19868         pImageFormatProperties = NULL;
19869     }
19870 
19871     return ret;
19872 }
19873 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)19874 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
19875 {
19876     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
19877     const VkFlags cmd_flags = 0;
19878     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19879 
19880     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19881     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
19882     if (pQueueFamilyPropertyCount)
19883         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
19884     if (pQueueFamilyProperties) {
19885         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
19886         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
19887             cmd_size += vn_sizeof_VkQueueFamilyProperties2_partial(&pQueueFamilyProperties[i]);
19888     } else {
19889         cmd_size += vn_sizeof_array_size(0);
19890     }
19891 
19892     return cmd_size;
19893 }
19894 
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)19895 static inline void vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
19896 {
19897     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
19898 
19899     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19900     vn_encode_VkFlags(enc, &cmd_flags);
19901 
19902     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19903     if (vn_encode_simple_pointer(enc, pQueueFamilyPropertyCount))
19904         vn_encode_uint32_t(enc, pQueueFamilyPropertyCount);
19905     if (pQueueFamilyProperties) {
19906         vn_encode_array_size(enc, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
19907         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
19908             vn_encode_VkQueueFamilyProperties2_partial(enc, &pQueueFamilyProperties[i]);
19909     } else {
19910         vn_encode_array_size(enc, 0);
19911     }
19912 }
19913 
vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)19914 static inline size_t vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
19915 {
19916     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT;
19917     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19918 
19919     /* skip physicalDevice */
19920     cmd_size += vn_sizeof_simple_pointer(pQueueFamilyPropertyCount);
19921     if (pQueueFamilyPropertyCount)
19922         cmd_size += vn_sizeof_uint32_t(pQueueFamilyPropertyCount);
19923     if (pQueueFamilyProperties) {
19924         cmd_size += vn_sizeof_array_size((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
19925         for (uint32_t i = 0; i < (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); i++)
19926             cmd_size += vn_sizeof_VkQueueFamilyProperties2(&pQueueFamilyProperties[i]);
19927     } else {
19928         cmd_size += vn_sizeof_array_size(0);
19929     }
19930 
19931     return cmd_size;
19932 }
19933 
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)19934 static inline void vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
19935 {
19936     VkCommandTypeEXT command_type;
19937     vn_decode_VkCommandTypeEXT(dec, &command_type);
19938     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceQueueFamilyProperties2_EXT);
19939 
19940     /* skip physicalDevice */
19941     if (vn_decode_simple_pointer(dec)) {
19942         vn_decode_uint32_t(dec, pQueueFamilyPropertyCount);
19943     } else {
19944         pQueueFamilyPropertyCount = NULL;
19945     }
19946     if (vn_peek_array_size(dec)) {
19947         const uint32_t iter_count = vn_decode_array_size(dec, (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0));
19948         for (uint32_t i = 0; i < iter_count; i++)
19949             vn_decode_VkQueueFamilyProperties2(dec, &pQueueFamilyProperties[i]);
19950     } else {
19951         vn_decode_array_size_unchecked(dec);
19952         pQueueFamilyProperties = NULL;
19953     }
19954 }
19955 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)19956 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
19957 {
19958     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
19959     const VkFlags cmd_flags = 0;
19960     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
19961 
19962     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
19963     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
19964     if (pMemoryProperties)
19965         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2_partial(pMemoryProperties);
19966 
19967     return cmd_size;
19968 }
19969 
vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)19970 static inline void vn_encode_vkGetPhysicalDeviceMemoryProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
19971 {
19972     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
19973 
19974     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
19975     vn_encode_VkFlags(enc, &cmd_flags);
19976 
19977     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
19978     if (vn_encode_simple_pointer(enc, pMemoryProperties))
19979         vn_encode_VkPhysicalDeviceMemoryProperties2_partial(enc, pMemoryProperties);
19980 }
19981 
vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)19982 static inline size_t vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
19983 {
19984     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT;
19985     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
19986 
19987     /* skip physicalDevice */
19988     cmd_size += vn_sizeof_simple_pointer(pMemoryProperties);
19989     if (pMemoryProperties)
19990         cmd_size += vn_sizeof_VkPhysicalDeviceMemoryProperties2(pMemoryProperties);
19991 
19992     return cmd_size;
19993 }
19994 
vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)19995 static inline void vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
19996 {
19997     VkCommandTypeEXT command_type;
19998     vn_decode_VkCommandTypeEXT(dec, &command_type);
19999     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceMemoryProperties2_EXT);
20000 
20001     /* skip physicalDevice */
20002     if (vn_decode_simple_pointer(dec)) {
20003         vn_decode_VkPhysicalDeviceMemoryProperties2(dec, pMemoryProperties);
20004     } else {
20005         pMemoryProperties = NULL;
20006     }
20007 }
20008 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)20009 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
20010 {
20011     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
20012     const VkFlags cmd_flags = 0;
20013     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20014 
20015     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
20016     cmd_size += vn_sizeof_simple_pointer(pFormatInfo);
20017     if (pFormatInfo)
20018         cmd_size += vn_sizeof_VkPhysicalDeviceSparseImageFormatInfo2(pFormatInfo);
20019     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
20020     if (pPropertyCount)
20021         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
20022     if (pProperties) {
20023         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
20024         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
20025             cmd_size += vn_sizeof_VkSparseImageFormatProperties2_partial(&pProperties[i]);
20026     } else {
20027         cmd_size += vn_sizeof_array_size(0);
20028     }
20029 
20030     return cmd_size;
20031 }
20032 
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)20033 static inline void vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
20034 {
20035     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
20036 
20037     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20038     vn_encode_VkFlags(enc, &cmd_flags);
20039 
20040     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
20041     if (vn_encode_simple_pointer(enc, pFormatInfo))
20042         vn_encode_VkPhysicalDeviceSparseImageFormatInfo2(enc, pFormatInfo);
20043     if (vn_encode_simple_pointer(enc, pPropertyCount))
20044         vn_encode_uint32_t(enc, pPropertyCount);
20045     if (pProperties) {
20046         vn_encode_array_size(enc, (pPropertyCount ? *pPropertyCount : 0));
20047         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
20048             vn_encode_VkSparseImageFormatProperties2_partial(enc, &pProperties[i]);
20049     } else {
20050         vn_encode_array_size(enc, 0);
20051     }
20052 }
20053 
vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)20054 static inline size_t vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
20055 {
20056     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT;
20057     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20058 
20059     /* skip physicalDevice */
20060     /* skip pFormatInfo */
20061     cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
20062     if (pPropertyCount)
20063         cmd_size += vn_sizeof_uint32_t(pPropertyCount);
20064     if (pProperties) {
20065         cmd_size += vn_sizeof_array_size((pPropertyCount ? *pPropertyCount : 0));
20066         for (uint32_t i = 0; i < (pPropertyCount ? *pPropertyCount : 0); i++)
20067             cmd_size += vn_sizeof_VkSparseImageFormatProperties2(&pProperties[i]);
20068     } else {
20069         cmd_size += vn_sizeof_array_size(0);
20070     }
20071 
20072     return cmd_size;
20073 }
20074 
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)20075 static inline void vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
20076 {
20077     VkCommandTypeEXT command_type;
20078     vn_decode_VkCommandTypeEXT(dec, &command_type);
20079     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceSparseImageFormatProperties2_EXT);
20080 
20081     /* skip physicalDevice */
20082     /* skip pFormatInfo */
20083     if (vn_decode_simple_pointer(dec)) {
20084         vn_decode_uint32_t(dec, pPropertyCount);
20085     } else {
20086         pPropertyCount = NULL;
20087     }
20088     if (vn_peek_array_size(dec)) {
20089         const uint32_t iter_count = vn_decode_array_size(dec, (pPropertyCount ? *pPropertyCount : 0));
20090         for (uint32_t i = 0; i < iter_count; i++)
20091             vn_decode_VkSparseImageFormatProperties2(dec, &pProperties[i]);
20092     } else {
20093         vn_decode_array_size_unchecked(dec);
20094         pProperties = NULL;
20095     }
20096 }
20097 
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)20098 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
20099 {
20100     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
20101     const VkFlags cmd_flags = 0;
20102     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20103 
20104     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
20105     cmd_size += vn_sizeof_simple_pointer(pExternalBufferInfo);
20106     if (pExternalBufferInfo)
20107         cmd_size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo(pExternalBufferInfo);
20108     cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
20109     if (pExternalBufferProperties)
20110         cmd_size += vn_sizeof_VkExternalBufferProperties_partial(pExternalBufferProperties);
20111 
20112     return cmd_size;
20113 }
20114 
vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)20115 static inline void vn_encode_vkGetPhysicalDeviceExternalBufferProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
20116 {
20117     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
20118 
20119     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20120     vn_encode_VkFlags(enc, &cmd_flags);
20121 
20122     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
20123     if (vn_encode_simple_pointer(enc, pExternalBufferInfo))
20124         vn_encode_VkPhysicalDeviceExternalBufferInfo(enc, pExternalBufferInfo);
20125     if (vn_encode_simple_pointer(enc, pExternalBufferProperties))
20126         vn_encode_VkExternalBufferProperties_partial(enc, pExternalBufferProperties);
20127 }
20128 
vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)20129 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
20130 {
20131     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT;
20132     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20133 
20134     /* skip physicalDevice */
20135     /* skip pExternalBufferInfo */
20136     cmd_size += vn_sizeof_simple_pointer(pExternalBufferProperties);
20137     if (pExternalBufferProperties)
20138         cmd_size += vn_sizeof_VkExternalBufferProperties(pExternalBufferProperties);
20139 
20140     return cmd_size;
20141 }
20142 
vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)20143 static inline void vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
20144 {
20145     VkCommandTypeEXT command_type;
20146     vn_decode_VkCommandTypeEXT(dec, &command_type);
20147     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalBufferProperties_EXT);
20148 
20149     /* skip physicalDevice */
20150     /* skip pExternalBufferInfo */
20151     if (vn_decode_simple_pointer(dec)) {
20152         vn_decode_VkExternalBufferProperties(dec, pExternalBufferProperties);
20153     } else {
20154         pExternalBufferProperties = NULL;
20155     }
20156 }
20157 
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)20158 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
20159 {
20160     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
20161     const VkFlags cmd_flags = 0;
20162     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20163 
20164     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
20165     cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreInfo);
20166     if (pExternalSemaphoreInfo)
20167         cmd_size += vn_sizeof_VkPhysicalDeviceExternalSemaphoreInfo(pExternalSemaphoreInfo);
20168     cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
20169     if (pExternalSemaphoreProperties)
20170         cmd_size += vn_sizeof_VkExternalSemaphoreProperties_partial(pExternalSemaphoreProperties);
20171 
20172     return cmd_size;
20173 }
20174 
vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)20175 static inline void vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
20176 {
20177     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
20178 
20179     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20180     vn_encode_VkFlags(enc, &cmd_flags);
20181 
20182     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
20183     if (vn_encode_simple_pointer(enc, pExternalSemaphoreInfo))
20184         vn_encode_VkPhysicalDeviceExternalSemaphoreInfo(enc, pExternalSemaphoreInfo);
20185     if (vn_encode_simple_pointer(enc, pExternalSemaphoreProperties))
20186         vn_encode_VkExternalSemaphoreProperties_partial(enc, pExternalSemaphoreProperties);
20187 }
20188 
vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)20189 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
20190 {
20191     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT;
20192     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20193 
20194     /* skip physicalDevice */
20195     /* skip pExternalSemaphoreInfo */
20196     cmd_size += vn_sizeof_simple_pointer(pExternalSemaphoreProperties);
20197     if (pExternalSemaphoreProperties)
20198         cmd_size += vn_sizeof_VkExternalSemaphoreProperties(pExternalSemaphoreProperties);
20199 
20200     return cmd_size;
20201 }
20202 
vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)20203 static inline void vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
20204 {
20205     VkCommandTypeEXT command_type;
20206     vn_decode_VkCommandTypeEXT(dec, &command_type);
20207     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalSemaphoreProperties_EXT);
20208 
20209     /* skip physicalDevice */
20210     /* skip pExternalSemaphoreInfo */
20211     if (vn_decode_simple_pointer(dec)) {
20212         vn_decode_VkExternalSemaphoreProperties(dec, pExternalSemaphoreProperties);
20213     } else {
20214         pExternalSemaphoreProperties = NULL;
20215     }
20216 }
20217 
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)20218 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
20219 {
20220     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
20221     const VkFlags cmd_flags = 0;
20222     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20223 
20224     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
20225     cmd_size += vn_sizeof_simple_pointer(pExternalFenceInfo);
20226     if (pExternalFenceInfo)
20227         cmd_size += vn_sizeof_VkPhysicalDeviceExternalFenceInfo(pExternalFenceInfo);
20228     cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
20229     if (pExternalFenceProperties)
20230         cmd_size += vn_sizeof_VkExternalFenceProperties_partial(pExternalFenceProperties);
20231 
20232     return cmd_size;
20233 }
20234 
vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)20235 static inline void vn_encode_vkGetPhysicalDeviceExternalFenceProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
20236 {
20237     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
20238 
20239     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20240     vn_encode_VkFlags(enc, &cmd_flags);
20241 
20242     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
20243     if (vn_encode_simple_pointer(enc, pExternalFenceInfo))
20244         vn_encode_VkPhysicalDeviceExternalFenceInfo(enc, pExternalFenceInfo);
20245     if (vn_encode_simple_pointer(enc, pExternalFenceProperties))
20246         vn_encode_VkExternalFenceProperties_partial(enc, pExternalFenceProperties);
20247 }
20248 
vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)20249 static inline size_t vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
20250 {
20251     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT;
20252     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20253 
20254     /* skip physicalDevice */
20255     /* skip pExternalFenceInfo */
20256     cmd_size += vn_sizeof_simple_pointer(pExternalFenceProperties);
20257     if (pExternalFenceProperties)
20258         cmd_size += vn_sizeof_VkExternalFenceProperties(pExternalFenceProperties);
20259 
20260     return cmd_size;
20261 }
20262 
vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)20263 static inline void vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
20264 {
20265     VkCommandTypeEXT command_type;
20266     vn_decode_VkCommandTypeEXT(dec, &command_type);
20267     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceExternalFenceProperties_EXT);
20268 
20269     /* skip physicalDevice */
20270     /* skip pExternalFenceInfo */
20271     if (vn_decode_simple_pointer(dec)) {
20272         vn_decode_VkExternalFenceProperties(dec, pExternalFenceProperties);
20273     } else {
20274         pExternalFenceProperties = NULL;
20275     }
20276 }
20277 
vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)20278 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
20279 {
20280     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
20281     const VkFlags cmd_flags = 0;
20282     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20283 
20284     cmd_size += vn_sizeof_VkInstance(&instance);
20285     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
20286     if (pPhysicalDeviceGroupCount)
20287         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
20288     if (pPhysicalDeviceGroupProperties) {
20289         cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
20290         for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
20291             cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties_partial(&pPhysicalDeviceGroupProperties[i]);
20292     } else {
20293         cmd_size += vn_sizeof_array_size(0);
20294     }
20295 
20296     return cmd_size;
20297 }
20298 
vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)20299 static inline void vn_encode_vkEnumeratePhysicalDeviceGroups(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
20300 {
20301     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
20302 
20303     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20304     vn_encode_VkFlags(enc, &cmd_flags);
20305 
20306     vn_encode_VkInstance(enc, &instance);
20307     if (vn_encode_simple_pointer(enc, pPhysicalDeviceGroupCount))
20308         vn_encode_uint32_t(enc, pPhysicalDeviceGroupCount);
20309     if (pPhysicalDeviceGroupProperties) {
20310         vn_encode_array_size(enc, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
20311         for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
20312             vn_encode_VkPhysicalDeviceGroupProperties_partial(enc, &pPhysicalDeviceGroupProperties[i]);
20313     } else {
20314         vn_encode_array_size(enc, 0);
20315     }
20316 }
20317 
vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)20318 static inline size_t vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
20319 {
20320     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT;
20321     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20322 
20323     VkResult ret;
20324     cmd_size += vn_sizeof_VkResult(&ret);
20325     /* skip instance */
20326     cmd_size += vn_sizeof_simple_pointer(pPhysicalDeviceGroupCount);
20327     if (pPhysicalDeviceGroupCount)
20328         cmd_size += vn_sizeof_uint32_t(pPhysicalDeviceGroupCount);
20329     if (pPhysicalDeviceGroupProperties) {
20330         cmd_size += vn_sizeof_array_size((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
20331         for (uint32_t i = 0; i < (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); i++)
20332             cmd_size += vn_sizeof_VkPhysicalDeviceGroupProperties(&pPhysicalDeviceGroupProperties[i]);
20333     } else {
20334         cmd_size += vn_sizeof_array_size(0);
20335     }
20336 
20337     return cmd_size;
20338 }
20339 
vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder * dec,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)20340 static inline VkResult vn_decode_vkEnumeratePhysicalDeviceGroups_reply(struct vn_cs_decoder *dec, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
20341 {
20342     VkCommandTypeEXT command_type;
20343     vn_decode_VkCommandTypeEXT(dec, &command_type);
20344     assert(command_type == VK_COMMAND_TYPE_vkEnumeratePhysicalDeviceGroups_EXT);
20345 
20346     VkResult ret;
20347     vn_decode_VkResult(dec, &ret);
20348     /* skip instance */
20349     if (vn_decode_simple_pointer(dec)) {
20350         vn_decode_uint32_t(dec, pPhysicalDeviceGroupCount);
20351     } else {
20352         pPhysicalDeviceGroupCount = NULL;
20353     }
20354     if (vn_peek_array_size(dec)) {
20355         const uint32_t iter_count = vn_decode_array_size(dec, (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0));
20356         for (uint32_t i = 0; i < iter_count; i++)
20357             vn_decode_VkPhysicalDeviceGroupProperties(dec, &pPhysicalDeviceGroupProperties[i]);
20358     } else {
20359         vn_decode_array_size_unchecked(dec);
20360         pPhysicalDeviceGroupProperties = NULL;
20361     }
20362 
20363     return ret;
20364 }
20365 
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)20366 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
20367 {
20368     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
20369     const VkFlags cmd_flags = 0;
20370     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20371 
20372     cmd_size += vn_sizeof_VkDevice(&device);
20373     cmd_size += vn_sizeof_uint32_t(&heapIndex);
20374     cmd_size += vn_sizeof_uint32_t(&localDeviceIndex);
20375     cmd_size += vn_sizeof_uint32_t(&remoteDeviceIndex);
20376     cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures); /* out */
20377 
20378     return cmd_size;
20379 }
20380 
vn_encode_vkGetDeviceGroupPeerMemoryFeatures(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)20381 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)
20382 {
20383     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
20384 
20385     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20386     vn_encode_VkFlags(enc, &cmd_flags);
20387 
20388     vn_encode_VkDevice(enc, &device);
20389     vn_encode_uint32_t(enc, &heapIndex);
20390     vn_encode_uint32_t(enc, &localDeviceIndex);
20391     vn_encode_uint32_t(enc, &remoteDeviceIndex);
20392     vn_encode_simple_pointer(enc, pPeerMemoryFeatures); /* out */
20393 }
20394 
vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)20395 static inline size_t vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
20396 {
20397     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT;
20398     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20399 
20400     /* skip device */
20401     /* skip heapIndex */
20402     /* skip localDeviceIndex */
20403     /* skip remoteDeviceIndex */
20404     cmd_size += vn_sizeof_simple_pointer(pPeerMemoryFeatures);
20405     if (pPeerMemoryFeatures)
20406         cmd_size += vn_sizeof_VkFlags(pPeerMemoryFeatures);
20407 
20408     return cmd_size;
20409 }
20410 
vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)20411 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)
20412 {
20413     VkCommandTypeEXT command_type;
20414     vn_decode_VkCommandTypeEXT(dec, &command_type);
20415     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceGroupPeerMemoryFeatures_EXT);
20416 
20417     /* skip device */
20418     /* skip heapIndex */
20419     /* skip localDeviceIndex */
20420     /* skip remoteDeviceIndex */
20421     if (vn_decode_simple_pointer(dec)) {
20422         vn_decode_VkFlags(dec, pPeerMemoryFeatures);
20423     } else {
20424         pPeerMemoryFeatures = NULL;
20425     }
20426 }
20427 
vn_sizeof_vkGetDeviceQueue2(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)20428 static inline size_t vn_sizeof_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
20429 {
20430     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
20431     const VkFlags cmd_flags = 0;
20432     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20433 
20434     cmd_size += vn_sizeof_VkDevice(&device);
20435     cmd_size += vn_sizeof_simple_pointer(pQueueInfo);
20436     if (pQueueInfo)
20437         cmd_size += vn_sizeof_VkDeviceQueueInfo2(pQueueInfo);
20438     cmd_size += vn_sizeof_simple_pointer(pQueue);
20439     if (pQueue)
20440         cmd_size += vn_sizeof_VkQueue(pQueue);
20441 
20442     return cmd_size;
20443 }
20444 
vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)20445 static inline void vn_encode_vkGetDeviceQueue2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
20446 {
20447     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
20448 
20449     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20450     vn_encode_VkFlags(enc, &cmd_flags);
20451 
20452     vn_encode_VkDevice(enc, &device);
20453     if (vn_encode_simple_pointer(enc, pQueueInfo))
20454         vn_encode_VkDeviceQueueInfo2(enc, pQueueInfo);
20455     if (vn_encode_simple_pointer(enc, pQueue))
20456         vn_encode_VkQueue(enc, pQueue);
20457 }
20458 
vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)20459 static inline size_t vn_sizeof_vkGetDeviceQueue2_reply(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
20460 {
20461     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT;
20462     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20463 
20464     /* skip device */
20465     /* skip pQueueInfo */
20466     cmd_size += vn_sizeof_simple_pointer(pQueue);
20467     if (pQueue)
20468         cmd_size += vn_sizeof_VkQueue(pQueue);
20469 
20470     return cmd_size;
20471 }
20472 
vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder * dec,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)20473 static inline void vn_decode_vkGetDeviceQueue2_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
20474 {
20475     VkCommandTypeEXT command_type;
20476     vn_decode_VkCommandTypeEXT(dec, &command_type);
20477     assert(command_type == VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT);
20478 
20479     /* skip device */
20480     /* skip pQueueInfo */
20481     if (vn_decode_simple_pointer(dec)) {
20482         vn_decode_VkQueue(dec, pQueue);
20483     } else {
20484         pQueue = NULL;
20485     }
20486 }
20487 
vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)20488 static inline size_t vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
20489 {
20490     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT;
20491     const VkFlags cmd_flags = 0;
20492     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20493 
20494     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
20495     cmd_size += vn_sizeof_simple_pointer(pTimeDomainCount);
20496     if (pTimeDomainCount)
20497         cmd_size += vn_sizeof_uint32_t(pTimeDomainCount);
20498     cmd_size += vn_sizeof_simple_pointer(pTimeDomains); /* out */
20499 
20500     return cmd_size;
20501 }
20502 
vn_encode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)20503 static inline void vn_encode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
20504 {
20505     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT;
20506 
20507     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20508     vn_encode_VkFlags(enc, &cmd_flags);
20509 
20510     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
20511     if (vn_encode_simple_pointer(enc, pTimeDomainCount))
20512         vn_encode_uint32_t(enc, pTimeDomainCount);
20513     vn_encode_array_size(enc, pTimeDomains ? (pTimeDomainCount ? *pTimeDomainCount : 0) : 0); /* out */
20514 }
20515 
vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)20516 static inline size_t vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
20517 {
20518     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT;
20519     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20520 
20521     VkResult ret;
20522     cmd_size += vn_sizeof_VkResult(&ret);
20523     /* skip physicalDevice */
20524     cmd_size += vn_sizeof_simple_pointer(pTimeDomainCount);
20525     if (pTimeDomainCount)
20526         cmd_size += vn_sizeof_uint32_t(pTimeDomainCount);
20527     if (pTimeDomains) {
20528         cmd_size += vn_sizeof_array_size((pTimeDomainCount ? *pTimeDomainCount : 0));
20529         cmd_size += vn_sizeof_VkTimeDomainEXT_array(pTimeDomains, (pTimeDomainCount ? *pTimeDomainCount : 0));
20530     } else {
20531         cmd_size += vn_sizeof_array_size(0);
20532     }
20533 
20534     return cmd_size;
20535 }
20536 
vn_decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)20537 static inline VkResult vn_decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
20538 {
20539     VkCommandTypeEXT command_type;
20540     vn_decode_VkCommandTypeEXT(dec, &command_type);
20541     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_EXT);
20542 
20543     VkResult ret;
20544     vn_decode_VkResult(dec, &ret);
20545     /* skip physicalDevice */
20546     if (vn_decode_simple_pointer(dec)) {
20547         vn_decode_uint32_t(dec, pTimeDomainCount);
20548     } else {
20549         pTimeDomainCount = NULL;
20550     }
20551     if (vn_peek_array_size(dec)) {
20552         const size_t array_size = vn_decode_array_size(dec, (pTimeDomainCount ? *pTimeDomainCount : 0));
20553         vn_decode_VkTimeDomainEXT_array(dec, pTimeDomains, array_size);
20554     } else {
20555         vn_decode_array_size_unchecked(dec);
20556         pTimeDomains = NULL;
20557     }
20558 
20559     return ret;
20560 }
20561 
vn_sizeof_vkGetCalibratedTimestampsEXT(VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)20562 static inline size_t vn_sizeof_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
20563 {
20564     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT;
20565     const VkFlags cmd_flags = 0;
20566     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20567 
20568     cmd_size += vn_sizeof_VkDevice(&device);
20569     cmd_size += vn_sizeof_uint32_t(&timestampCount);
20570     if (pTimestampInfos) {
20571         cmd_size += vn_sizeof_array_size(timestampCount);
20572         for (uint32_t i = 0; i < timestampCount; i++)
20573             cmd_size += vn_sizeof_VkCalibratedTimestampInfoEXT(&pTimestampInfos[i]);
20574     } else {
20575         cmd_size += vn_sizeof_array_size(0);
20576     }
20577     cmd_size += vn_sizeof_simple_pointer(pTimestamps); /* out */
20578     cmd_size += vn_sizeof_simple_pointer(pMaxDeviation); /* out */
20579 
20580     return cmd_size;
20581 }
20582 
vn_encode_vkGetCalibratedTimestampsEXT(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)20583 static inline void vn_encode_vkGetCalibratedTimestampsEXT(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
20584 {
20585     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT;
20586 
20587     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20588     vn_encode_VkFlags(enc, &cmd_flags);
20589 
20590     vn_encode_VkDevice(enc, &device);
20591     vn_encode_uint32_t(enc, &timestampCount);
20592     if (pTimestampInfos) {
20593         vn_encode_array_size(enc, timestampCount);
20594         for (uint32_t i = 0; i < timestampCount; i++)
20595             vn_encode_VkCalibratedTimestampInfoEXT(enc, &pTimestampInfos[i]);
20596     } else {
20597         vn_encode_array_size(enc, 0);
20598     }
20599     vn_encode_array_size(enc, pTimestamps ? timestampCount : 0); /* out */
20600     vn_encode_simple_pointer(enc, pMaxDeviation); /* out */
20601 }
20602 
vn_sizeof_vkGetCalibratedTimestampsEXT_reply(VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)20603 static inline size_t vn_sizeof_vkGetCalibratedTimestampsEXT_reply(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
20604 {
20605     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT;
20606     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20607 
20608     VkResult ret;
20609     cmd_size += vn_sizeof_VkResult(&ret);
20610     /* skip device */
20611     /* skip timestampCount */
20612     /* skip pTimestampInfos */
20613     if (pTimestamps) {
20614         cmd_size += vn_sizeof_array_size(timestampCount);
20615         cmd_size += vn_sizeof_uint64_t_array(pTimestamps, timestampCount);
20616     } else {
20617         cmd_size += vn_sizeof_array_size(0);
20618     }
20619     cmd_size += vn_sizeof_simple_pointer(pMaxDeviation);
20620     if (pMaxDeviation)
20621         cmd_size += vn_sizeof_uint64_t(pMaxDeviation);
20622 
20623     return cmd_size;
20624 }
20625 
vn_decode_vkGetCalibratedTimestampsEXT_reply(struct vn_cs_decoder * dec,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)20626 static inline VkResult vn_decode_vkGetCalibratedTimestampsEXT_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
20627 {
20628     VkCommandTypeEXT command_type;
20629     vn_decode_VkCommandTypeEXT(dec, &command_type);
20630     assert(command_type == VK_COMMAND_TYPE_vkGetCalibratedTimestampsEXT_EXT);
20631 
20632     VkResult ret;
20633     vn_decode_VkResult(dec, &ret);
20634     /* skip device */
20635     /* skip timestampCount */
20636     /* skip pTimestampInfos */
20637     if (vn_peek_array_size(dec)) {
20638         const size_t array_size = vn_decode_array_size(dec, timestampCount);
20639         vn_decode_uint64_t_array(dec, pTimestamps, array_size);
20640     } else {
20641         vn_decode_array_size_unchecked(dec);
20642         pTimestamps = NULL;
20643     }
20644     if (vn_decode_simple_pointer(dec)) {
20645         vn_decode_uint64_t(dec, pMaxDeviation);
20646     } else {
20647         pMaxDeviation = NULL;
20648     }
20649 
20650     return ret;
20651 }
20652 
vn_sizeof_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)20653 static inline size_t vn_sizeof_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
20654 {
20655     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT;
20656     const VkFlags cmd_flags = 0;
20657     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
20658 
20659     cmd_size += vn_sizeof_VkPhysicalDevice(&physicalDevice);
20660     cmd_size += vn_sizeof_simple_pointer(pToolCount);
20661     if (pToolCount)
20662         cmd_size += vn_sizeof_uint32_t(pToolCount);
20663     if (pToolProperties) {
20664         cmd_size += vn_sizeof_array_size((pToolCount ? *pToolCount : 0));
20665         for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++)
20666             cmd_size += vn_sizeof_VkPhysicalDeviceToolProperties_partial(&pToolProperties[i]);
20667     } else {
20668         cmd_size += vn_sizeof_array_size(0);
20669     }
20670 
20671     return cmd_size;
20672 }
20673 
vn_encode_vkGetPhysicalDeviceToolProperties(struct vn_cs_encoder * enc,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)20674 static inline void vn_encode_vkGetPhysicalDeviceToolProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
20675 {
20676     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT;
20677 
20678     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
20679     vn_encode_VkFlags(enc, &cmd_flags);
20680 
20681     vn_encode_VkPhysicalDevice(enc, &physicalDevice);
20682     if (vn_encode_simple_pointer(enc, pToolCount))
20683         vn_encode_uint32_t(enc, pToolCount);
20684     if (pToolProperties) {
20685         vn_encode_array_size(enc, (pToolCount ? *pToolCount : 0));
20686         for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++)
20687             vn_encode_VkPhysicalDeviceToolProperties_partial(enc, &pToolProperties[i]);
20688     } else {
20689         vn_encode_array_size(enc, 0);
20690     }
20691 }
20692 
vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)20693 static inline size_t vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
20694 {
20695     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT;
20696     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
20697 
20698     VkResult ret;
20699     cmd_size += vn_sizeof_VkResult(&ret);
20700     /* skip physicalDevice */
20701     cmd_size += vn_sizeof_simple_pointer(pToolCount);
20702     if (pToolCount)
20703         cmd_size += vn_sizeof_uint32_t(pToolCount);
20704     if (pToolProperties) {
20705         cmd_size += vn_sizeof_array_size((pToolCount ? *pToolCount : 0));
20706         for (uint32_t i = 0; i < (pToolCount ? *pToolCount : 0); i++)
20707             cmd_size += vn_sizeof_VkPhysicalDeviceToolProperties(&pToolProperties[i]);
20708     } else {
20709         cmd_size += vn_sizeof_array_size(0);
20710     }
20711 
20712     return cmd_size;
20713 }
20714 
vn_decode_vkGetPhysicalDeviceToolProperties_reply(struct vn_cs_decoder * dec,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)20715 static inline VkResult vn_decode_vkGetPhysicalDeviceToolProperties_reply(struct vn_cs_decoder *dec, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
20716 {
20717     VkCommandTypeEXT command_type;
20718     vn_decode_VkCommandTypeEXT(dec, &command_type);
20719     assert(command_type == VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT);
20720 
20721     VkResult ret;
20722     vn_decode_VkResult(dec, &ret);
20723     /* skip physicalDevice */
20724     if (vn_decode_simple_pointer(dec)) {
20725         vn_decode_uint32_t(dec, pToolCount);
20726     } else {
20727         pToolCount = NULL;
20728     }
20729     if (vn_peek_array_size(dec)) {
20730         const uint32_t iter_count = vn_decode_array_size(dec, (pToolCount ? *pToolCount : 0));
20731         for (uint32_t i = 0; i < iter_count; i++)
20732             vn_decode_VkPhysicalDeviceToolProperties(dec, &pToolProperties[i]);
20733     } else {
20734         vn_decode_array_size_unchecked(dec);
20735         pToolProperties = NULL;
20736     }
20737 
20738     return ret;
20739 }
20740 
vn_submit_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices,struct vn_instance_submit_command * submit)20741 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)
20742 {
20743     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20744     void *cmd_data = local_cmd_data;
20745     size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
20746     if (cmd_size > sizeof(local_cmd_data)) {
20747         cmd_data = malloc(cmd_size);
20748         if (!cmd_data)
20749             cmd_size = 0;
20750     }
20751     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
20752 
20753     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20754     if (cmd_size) {
20755         vn_encode_vkEnumeratePhysicalDevices(enc, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
20756         vn_instance_submit_command(vn_instance, submit);
20757         if (cmd_data != local_cmd_data)
20758             free(cmd_data);
20759     }
20760 }
20761 
vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties,struct vn_instance_submit_command * submit)20762 static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_instance_submit_command *submit)
20763 {
20764     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20765     void *cmd_data = local_cmd_data;
20766     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
20767     if (cmd_size > sizeof(local_cmd_data)) {
20768         cmd_data = malloc(cmd_size);
20769         if (!cmd_data)
20770             cmd_size = 0;
20771     }
20772     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
20773 
20774     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20775     if (cmd_size) {
20776         vn_encode_vkGetPhysicalDeviceProperties(enc, cmd_flags, physicalDevice, pProperties);
20777         vn_instance_submit_command(vn_instance, submit);
20778         if (cmd_data != local_cmd_data)
20779             free(cmd_data);
20780     }
20781 }
20782 
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties,struct vn_instance_submit_command * submit)20783 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)
20784 {
20785     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20786     void *cmd_data = local_cmd_data;
20787     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
20788     if (cmd_size > sizeof(local_cmd_data)) {
20789         cmd_data = malloc(cmd_size);
20790         if (!cmd_data)
20791             cmd_size = 0;
20792     }
20793     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
20794 
20795     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20796     if (cmd_size) {
20797         vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
20798         vn_instance_submit_command(vn_instance, submit);
20799         if (cmd_data != local_cmd_data)
20800             free(cmd_data);
20801     }
20802 }
20803 
vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties,struct vn_instance_submit_command * submit)20804 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_instance_submit_command *submit)
20805 {
20806     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20807     void *cmd_data = local_cmd_data;
20808     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
20809     if (cmd_size > sizeof(local_cmd_data)) {
20810         cmd_data = malloc(cmd_size);
20811         if (!cmd_data)
20812             cmd_size = 0;
20813     }
20814     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
20815 
20816     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20817     if (cmd_size) {
20818         vn_encode_vkGetPhysicalDeviceMemoryProperties(enc, cmd_flags, physicalDevice, pMemoryProperties);
20819         vn_instance_submit_command(vn_instance, submit);
20820         if (cmd_data != local_cmd_data)
20821             free(cmd_data);
20822     }
20823 }
20824 
vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures,struct vn_instance_submit_command * submit)20825 static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_instance_submit_command *submit)
20826 {
20827     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20828     void *cmd_data = local_cmd_data;
20829     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
20830     if (cmd_size > sizeof(local_cmd_data)) {
20831         cmd_data = malloc(cmd_size);
20832         if (!cmd_data)
20833             cmd_size = 0;
20834     }
20835     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
20836 
20837     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20838     if (cmd_size) {
20839         vn_encode_vkGetPhysicalDeviceFeatures(enc, cmd_flags, physicalDevice, pFeatures);
20840         vn_instance_submit_command(vn_instance, submit);
20841         if (cmd_data != local_cmd_data)
20842             free(cmd_data);
20843     }
20844 }
20845 
vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties,struct vn_instance_submit_command * submit)20846 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)
20847 {
20848     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20849     void *cmd_data = local_cmd_data;
20850     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
20851     if (cmd_size > sizeof(local_cmd_data)) {
20852         cmd_data = malloc(cmd_size);
20853         if (!cmd_data)
20854             cmd_size = 0;
20855     }
20856     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
20857 
20858     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20859     if (cmd_size) {
20860         vn_encode_vkGetPhysicalDeviceFormatProperties(enc, cmd_flags, physicalDevice, format, pFormatProperties);
20861         vn_instance_submit_command(vn_instance, submit);
20862         if (cmd_data != local_cmd_data)
20863             free(cmd_data);
20864     }
20865 }
20866 
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)20867 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)
20868 {
20869     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20870     void *cmd_data = local_cmd_data;
20871     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
20872     if (cmd_size > sizeof(local_cmd_data)) {
20873         cmd_data = malloc(cmd_size);
20874         if (!cmd_data)
20875             cmd_size = 0;
20876     }
20877     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;
20878 
20879     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20880     if (cmd_size) {
20881         vn_encode_vkGetPhysicalDeviceImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
20882         vn_instance_submit_command(vn_instance, submit);
20883         if (cmd_data != local_cmd_data)
20884             free(cmd_data);
20885     }
20886 }
20887 
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)20888 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)
20889 {
20890     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20891     void *cmd_data = local_cmd_data;
20892     size_t cmd_size = vn_sizeof_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
20893     if (cmd_size > sizeof(local_cmd_data)) {
20894         cmd_data = malloc(cmd_size);
20895         if (!cmd_data)
20896             cmd_size = 0;
20897     }
20898     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
20899 
20900     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20901     if (cmd_size) {
20902         vn_encode_vkCreateDevice(enc, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
20903         vn_instance_submit_command(vn_instance, submit);
20904         if (cmd_data != local_cmd_data)
20905             free(cmd_data);
20906     }
20907 }
20908 
vn_submit_vkDestroyDevice(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkAllocationCallbacks * pAllocator,struct vn_instance_submit_command * submit)20909 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)
20910 {
20911     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20912     void *cmd_data = local_cmd_data;
20913     size_t cmd_size = vn_sizeof_vkDestroyDevice(device, pAllocator);
20914     if (cmd_size > sizeof(local_cmd_data)) {
20915         cmd_data = malloc(cmd_size);
20916         if (!cmd_data)
20917             cmd_size = 0;
20918     }
20919     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
20920 
20921     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20922     if (cmd_size) {
20923         vn_encode_vkDestroyDevice(enc, cmd_flags, device, pAllocator);
20924         vn_instance_submit_command(vn_instance, submit);
20925         if (cmd_data != local_cmd_data)
20926             free(cmd_data);
20927     }
20928 }
20929 
vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties,struct vn_instance_submit_command * submit)20930 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)
20931 {
20932     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20933     void *cmd_data = local_cmd_data;
20934     size_t cmd_size = vn_sizeof_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
20935     if (cmd_size > sizeof(local_cmd_data)) {
20936         cmd_data = malloc(cmd_size);
20937         if (!cmd_data)
20938             cmd_size = 0;
20939     }
20940     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
20941 
20942     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20943     if (cmd_size) {
20944         vn_encode_vkEnumerateDeviceLayerProperties(enc, cmd_flags, physicalDevice, pPropertyCount, pProperties);
20945         vn_instance_submit_command(vn_instance, submit);
20946         if (cmd_data != local_cmd_data)
20947             free(cmd_data);
20948     }
20949 }
20950 
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)20951 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)
20952 {
20953     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20954     void *cmd_data = local_cmd_data;
20955     size_t cmd_size = vn_sizeof_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
20956     if (cmd_size > sizeof(local_cmd_data)) {
20957         cmd_data = malloc(cmd_size);
20958         if (!cmd_data)
20959             cmd_size = 0;
20960     }
20961     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
20962 
20963     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20964     if (cmd_size) {
20965         vn_encode_vkEnumerateDeviceExtensionProperties(enc, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
20966         vn_instance_submit_command(vn_instance, submit);
20967         if (cmd_data != local_cmd_data)
20968             free(cmd_data);
20969     }
20970 }
20971 
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)20972 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)
20973 {
20974     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20975     void *cmd_data = local_cmd_data;
20976     size_t cmd_size = vn_sizeof_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
20977     if (cmd_size > sizeof(local_cmd_data)) {
20978         cmd_data = malloc(cmd_size);
20979         if (!cmd_data)
20980             cmd_size = 0;
20981     }
20982     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
20983 
20984     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
20985     if (cmd_size) {
20986         vn_encode_vkGetDeviceQueue(enc, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
20987         vn_instance_submit_command(vn_instance, submit);
20988         if (cmd_data != local_cmd_data)
20989             free(cmd_data);
20990     }
20991 }
20992 
vn_submit_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,struct vn_instance_submit_command * submit)20993 static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_instance_submit_command *submit)
20994 {
20995     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
20996     void *cmd_data = local_cmd_data;
20997     size_t cmd_size = vn_sizeof_vkDeviceWaitIdle(device);
20998     if (cmd_size > sizeof(local_cmd_data)) {
20999         cmd_data = malloc(cmd_size);
21000         if (!cmd_data)
21001             cmd_size = 0;
21002     }
21003     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
21004 
21005     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21006     if (cmd_size) {
21007         vn_encode_vkDeviceWaitIdle(enc, cmd_flags, device);
21008         vn_instance_submit_command(vn_instance, submit);
21009         if (cmd_data != local_cmd_data)
21010             free(cmd_data);
21011     }
21012 }
21013 
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)21014 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)
21015 {
21016     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21017     void *cmd_data = local_cmd_data;
21018     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
21019     if (cmd_size > sizeof(local_cmd_data)) {
21020         cmd_data = malloc(cmd_size);
21021         if (!cmd_data)
21022             cmd_size = 0;
21023     }
21024     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;
21025 
21026     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21027     if (cmd_size) {
21028         vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
21029         vn_instance_submit_command(vn_instance, submit);
21030         if (cmd_data != local_cmd_data)
21031             free(cmd_data);
21032     }
21033 }
21034 
vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures,struct vn_instance_submit_command * submit)21035 static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_instance_submit_command *submit)
21036 {
21037     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21038     void *cmd_data = local_cmd_data;
21039     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
21040     if (cmd_size > sizeof(local_cmd_data)) {
21041         cmd_data = malloc(cmd_size);
21042         if (!cmd_data)
21043             cmd_size = 0;
21044     }
21045     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
21046 
21047     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21048     if (cmd_size) {
21049         vn_encode_vkGetPhysicalDeviceFeatures2(enc, cmd_flags, physicalDevice, pFeatures);
21050         vn_instance_submit_command(vn_instance, submit);
21051         if (cmd_data != local_cmd_data)
21052             free(cmd_data);
21053     }
21054 }
21055 
vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties,struct vn_instance_submit_command * submit)21056 static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_instance_submit_command *submit)
21057 {
21058     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21059     void *cmd_data = local_cmd_data;
21060     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
21061     if (cmd_size > sizeof(local_cmd_data)) {
21062         cmd_data = malloc(cmd_size);
21063         if (!cmd_data)
21064             cmd_size = 0;
21065     }
21066     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
21067 
21068     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21069     if (cmd_size) {
21070         vn_encode_vkGetPhysicalDeviceProperties2(enc, cmd_flags, physicalDevice, pProperties);
21071         vn_instance_submit_command(vn_instance, submit);
21072         if (cmd_data != local_cmd_data)
21073             free(cmd_data);
21074     }
21075 }
21076 
vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties,struct vn_instance_submit_command * submit)21077 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)
21078 {
21079     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21080     void *cmd_data = local_cmd_data;
21081     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
21082     if (cmd_size > sizeof(local_cmd_data)) {
21083         cmd_data = malloc(cmd_size);
21084         if (!cmd_data)
21085             cmd_size = 0;
21086     }
21087     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
21088 
21089     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21090     if (cmd_size) {
21091         vn_encode_vkGetPhysicalDeviceFormatProperties2(enc, cmd_flags, physicalDevice, format, pFormatProperties);
21092         vn_instance_submit_command(vn_instance, submit);
21093         if (cmd_data != local_cmd_data)
21094             free(cmd_data);
21095     }
21096 }
21097 
vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties,struct vn_instance_submit_command * submit)21098 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)
21099 {
21100     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21101     void *cmd_data = local_cmd_data;
21102     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
21103     if (cmd_size > sizeof(local_cmd_data)) {
21104         cmd_data = malloc(cmd_size);
21105         if (!cmd_data)
21106             cmd_size = 0;
21107     }
21108     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
21109 
21110     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21111     if (cmd_size) {
21112         vn_encode_vkGetPhysicalDeviceImageFormatProperties2(enc, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
21113         vn_instance_submit_command(vn_instance, submit);
21114         if (cmd_data != local_cmd_data)
21115             free(cmd_data);
21116     }
21117 }
21118 
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties,struct vn_instance_submit_command * submit)21119 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)
21120 {
21121     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21122     void *cmd_data = local_cmd_data;
21123     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
21124     if (cmd_size > sizeof(local_cmd_data)) {
21125         cmd_data = malloc(cmd_size);
21126         if (!cmd_data)
21127             cmd_size = 0;
21128     }
21129     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
21130 
21131     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21132     if (cmd_size) {
21133         vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
21134         vn_instance_submit_command(vn_instance, submit);
21135         if (cmd_data != local_cmd_data)
21136             free(cmd_data);
21137     }
21138 }
21139 
vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties,struct vn_instance_submit_command * submit)21140 static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_instance_submit_command *submit)
21141 {
21142     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21143     void *cmd_data = local_cmd_data;
21144     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
21145     if (cmd_size > sizeof(local_cmd_data)) {
21146         cmd_data = malloc(cmd_size);
21147         if (!cmd_data)
21148             cmd_size = 0;
21149     }
21150     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
21151 
21152     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21153     if (cmd_size) {
21154         vn_encode_vkGetPhysicalDeviceMemoryProperties2(enc, cmd_flags, physicalDevice, pMemoryProperties);
21155         vn_instance_submit_command(vn_instance, submit);
21156         if (cmd_data != local_cmd_data)
21157             free(cmd_data);
21158     }
21159 }
21160 
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)21161 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)
21162 {
21163     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21164     void *cmd_data = local_cmd_data;
21165     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
21166     if (cmd_size > sizeof(local_cmd_data)) {
21167         cmd_data = malloc(cmd_size);
21168         if (!cmd_data)
21169             cmd_size = 0;
21170     }
21171     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
21172 
21173     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21174     if (cmd_size) {
21175         vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(enc, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
21176         vn_instance_submit_command(vn_instance, submit);
21177         if (cmd_data != local_cmd_data)
21178             free(cmd_data);
21179     }
21180 }
21181 
vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties,struct vn_instance_submit_command * submit)21182 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)
21183 {
21184     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21185     void *cmd_data = local_cmd_data;
21186     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
21187     if (cmd_size > sizeof(local_cmd_data)) {
21188         cmd_data = malloc(cmd_size);
21189         if (!cmd_data)
21190             cmd_size = 0;
21191     }
21192     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
21193 
21194     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21195     if (cmd_size) {
21196         vn_encode_vkGetPhysicalDeviceExternalBufferProperties(enc, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
21197         vn_instance_submit_command(vn_instance, submit);
21198         if (cmd_data != local_cmd_data)
21199             free(cmd_data);
21200     }
21201 }
21202 
vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties,struct vn_instance_submit_command * submit)21203 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)
21204 {
21205     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21206     void *cmd_data = local_cmd_data;
21207     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
21208     if (cmd_size > sizeof(local_cmd_data)) {
21209         cmd_data = malloc(cmd_size);
21210         if (!cmd_data)
21211             cmd_size = 0;
21212     }
21213     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
21214 
21215     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21216     if (cmd_size) {
21217         vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(enc, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
21218         vn_instance_submit_command(vn_instance, submit);
21219         if (cmd_data != local_cmd_data)
21220             free(cmd_data);
21221     }
21222 }
21223 
vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties,struct vn_instance_submit_command * submit)21224 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)
21225 {
21226     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21227     void *cmd_data = local_cmd_data;
21228     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
21229     if (cmd_size > sizeof(local_cmd_data)) {
21230         cmd_data = malloc(cmd_size);
21231         if (!cmd_data)
21232             cmd_size = 0;
21233     }
21234     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
21235 
21236     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21237     if (cmd_size) {
21238         vn_encode_vkGetPhysicalDeviceExternalFenceProperties(enc, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
21239         vn_instance_submit_command(vn_instance, submit);
21240         if (cmd_data != local_cmd_data)
21241             free(cmd_data);
21242     }
21243 }
21244 
vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,struct vn_instance_submit_command * submit)21245 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)
21246 {
21247     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21248     void *cmd_data = local_cmd_data;
21249     size_t cmd_size = vn_sizeof_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
21250     if (cmd_size > sizeof(local_cmd_data)) {
21251         cmd_data = malloc(cmd_size);
21252         if (!cmd_data)
21253             cmd_size = 0;
21254     }
21255     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
21256 
21257     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21258     if (cmd_size) {
21259         vn_encode_vkEnumeratePhysicalDeviceGroups(enc, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
21260         vn_instance_submit_command(vn_instance, submit);
21261         if (cmd_data != local_cmd_data)
21262             free(cmd_data);
21263     }
21264 }
21265 
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)21266 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)
21267 {
21268     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21269     void *cmd_data = local_cmd_data;
21270     size_t cmd_size = vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
21271     if (cmd_size > sizeof(local_cmd_data)) {
21272         cmd_data = malloc(cmd_size);
21273         if (!cmd_data)
21274             cmd_size = 0;
21275     }
21276     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
21277 
21278     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21279     if (cmd_size) {
21280         vn_encode_vkGetDeviceGroupPeerMemoryFeatures(enc, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
21281         vn_instance_submit_command(vn_instance, submit);
21282         if (cmd_data != local_cmd_data)
21283             free(cmd_data);
21284     }
21285 }
21286 
vn_submit_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue,struct vn_instance_submit_command * submit)21287 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)
21288 {
21289     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21290     void *cmd_data = local_cmd_data;
21291     size_t cmd_size = vn_sizeof_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
21292     if (cmd_size > sizeof(local_cmd_data)) {
21293         cmd_data = malloc(cmd_size);
21294         if (!cmd_data)
21295             cmd_size = 0;
21296     }
21297     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
21298 
21299     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21300     if (cmd_size) {
21301         vn_encode_vkGetDeviceQueue2(enc, cmd_flags, device, pQueueInfo, pQueue);
21302         vn_instance_submit_command(vn_instance, submit);
21303         if (cmd_data != local_cmd_data)
21304             free(cmd_data);
21305     }
21306 }
21307 
vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains,struct vn_instance_submit_command * submit)21308 static inline void vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains, struct vn_instance_submit_command *submit)
21309 {
21310     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21311     void *cmd_data = local_cmd_data;
21312     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
21313     if (cmd_size > sizeof(local_cmd_data)) {
21314         cmd_data = malloc(cmd_size);
21315         if (!cmd_data)
21316             cmd_size = 0;
21317     }
21318     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(physicalDevice, pTimeDomainCount, pTimeDomains) : 0;
21319 
21320     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21321     if (cmd_size) {
21322         vn_encode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(enc, cmd_flags, physicalDevice, pTimeDomainCount, pTimeDomains);
21323         vn_instance_submit_command(vn_instance, submit);
21324         if (cmd_data != local_cmd_data)
21325             free(cmd_data);
21326     }
21327 }
21328 
vn_submit_vkGetCalibratedTimestampsEXT(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation,struct vn_instance_submit_command * submit)21329 static inline void vn_submit_vkGetCalibratedTimestampsEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, struct vn_instance_submit_command *submit)
21330 {
21331     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21332     void *cmd_data = local_cmd_data;
21333     size_t cmd_size = vn_sizeof_vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
21334     if (cmd_size > sizeof(local_cmd_data)) {
21335         cmd_data = malloc(cmd_size);
21336         if (!cmd_data)
21337             cmd_size = 0;
21338     }
21339     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetCalibratedTimestampsEXT_reply(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation) : 0;
21340 
21341     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21342     if (cmd_size) {
21343         vn_encode_vkGetCalibratedTimestampsEXT(enc, cmd_flags, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
21344         vn_instance_submit_command(vn_instance, submit);
21345         if (cmd_data != local_cmd_data)
21346             free(cmd_data);
21347     }
21348 }
21349 
vn_submit_vkGetPhysicalDeviceToolProperties(struct vn_instance * vn_instance,VkCommandFlagsEXT cmd_flags,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties,struct vn_instance_submit_command * submit)21350 static inline void vn_submit_vkGetPhysicalDeviceToolProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, struct vn_instance_submit_command *submit)
21351 {
21352     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
21353     void *cmd_data = local_cmd_data;
21354     size_t cmd_size = vn_sizeof_vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties);
21355     if (cmd_size > sizeof(local_cmd_data)) {
21356         cmd_data = malloc(cmd_size);
21357         if (!cmd_data)
21358             cmd_size = 0;
21359     }
21360     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceToolProperties_reply(physicalDevice, pToolCount, pToolProperties) : 0;
21361 
21362     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
21363     if (cmd_size) {
21364         vn_encode_vkGetPhysicalDeviceToolProperties(enc, cmd_flags, physicalDevice, pToolCount, pToolProperties);
21365         vn_instance_submit_command(vn_instance, submit);
21366         if (cmd_data != local_cmd_data)
21367             free(cmd_data);
21368     }
21369 }
21370 
vn_call_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)21371 static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
21372 {
21373     VN_TRACE_FUNC();
21374 
21375     struct vn_instance_submit_command submit;
21376     vn_submit_vkEnumeratePhysicalDevices(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
21377     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21378     if (dec) {
21379         const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(dec, instance, pPhysicalDeviceCount, pPhysicalDevices);
21380         vn_instance_free_command_reply(vn_instance, &submit);
21381         return ret;
21382     } else {
21383         return VK_ERROR_OUT_OF_HOST_MEMORY;
21384     }
21385 }
21386 
vn_async_vkEnumeratePhysicalDevices(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)21387 static inline void vn_async_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
21388 {
21389     struct vn_instance_submit_command submit;
21390     vn_submit_vkEnumeratePhysicalDevices(vn_instance, 0, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
21391 }
21392 
vn_call_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)21393 static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
21394 {
21395     VN_TRACE_FUNC();
21396 
21397     struct vn_instance_submit_command submit;
21398     vn_submit_vkGetPhysicalDeviceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
21399     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21400     if (dec) {
21401         vn_decode_vkGetPhysicalDeviceProperties_reply(dec, physicalDevice, pProperties);
21402         vn_instance_free_command_reply(vn_instance, &submit);
21403     }
21404 }
21405 
vn_async_vkGetPhysicalDeviceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)21406 static inline void vn_async_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
21407 {
21408     struct vn_instance_submit_command submit;
21409     vn_submit_vkGetPhysicalDeviceProperties(vn_instance, 0, physicalDevice, pProperties, &submit);
21410 }
21411 
vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)21412 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
21413 {
21414     VN_TRACE_FUNC();
21415 
21416     struct vn_instance_submit_command submit;
21417     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
21418     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21419     if (dec) {
21420         vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
21421         vn_instance_free_command_reply(vn_instance, &submit);
21422     }
21423 }
21424 
vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)21425 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
21426 {
21427     struct vn_instance_submit_command submit;
21428     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
21429 }
21430 
vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)21431 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
21432 {
21433     VN_TRACE_FUNC();
21434 
21435     struct vn_instance_submit_command submit;
21436     vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
21437     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21438     if (dec) {
21439         vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(dec, physicalDevice, pMemoryProperties);
21440         vn_instance_free_command_reply(vn_instance, &submit);
21441     }
21442 }
21443 
vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)21444 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
21445 {
21446     struct vn_instance_submit_command submit;
21447     vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
21448 }
21449 
vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)21450 static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
21451 {
21452     VN_TRACE_FUNC();
21453 
21454     struct vn_instance_submit_command submit;
21455     vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
21456     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21457     if (dec) {
21458         vn_decode_vkGetPhysicalDeviceFeatures_reply(dec, physicalDevice, pFeatures);
21459         vn_instance_free_command_reply(vn_instance, &submit);
21460     }
21461 }
21462 
vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)21463 static inline void vn_async_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
21464 {
21465     struct vn_instance_submit_command submit;
21466     vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, 0, physicalDevice, pFeatures, &submit);
21467 }
21468 
vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)21469 static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
21470 {
21471     VN_TRACE_FUNC();
21472 
21473     struct vn_instance_submit_command submit;
21474     vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
21475     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21476     if (dec) {
21477         vn_decode_vkGetPhysicalDeviceFormatProperties_reply(dec, physicalDevice, format, pFormatProperties);
21478         vn_instance_free_command_reply(vn_instance, &submit);
21479     }
21480 }
21481 
vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)21482 static inline void vn_async_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
21483 {
21484     struct vn_instance_submit_command submit;
21485     vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
21486 }
21487 
vn_call_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)21488 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)
21489 {
21490     VN_TRACE_FUNC();
21491 
21492     struct vn_instance_submit_command submit;
21493     vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
21494     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21495     if (dec) {
21496         const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(dec, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
21497         vn_instance_free_command_reply(vn_instance, &submit);
21498         return ret;
21499     } else {
21500         return VK_ERROR_OUT_OF_HOST_MEMORY;
21501     }
21502 }
21503 
vn_async_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)21504 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)
21505 {
21506     struct vn_instance_submit_command submit;
21507     vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, 0, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
21508 }
21509 
vn_call_vkCreateDevice(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)21510 static inline VkResult vn_call_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
21511 {
21512     VN_TRACE_FUNC();
21513 
21514     struct vn_instance_submit_command submit;
21515     vn_submit_vkCreateDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
21516     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21517     if (dec) {
21518         const VkResult ret = vn_decode_vkCreateDevice_reply(dec, physicalDevice, pCreateInfo, pAllocator, pDevice);
21519         vn_instance_free_command_reply(vn_instance, &submit);
21520         return ret;
21521     } else {
21522         return VK_ERROR_OUT_OF_HOST_MEMORY;
21523     }
21524 }
21525 
vn_async_vkCreateDevice(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)21526 static inline void vn_async_vkCreateDevice(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
21527 {
21528     struct vn_instance_submit_command submit;
21529     vn_submit_vkCreateDevice(vn_instance, 0, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
21530 }
21531 
vn_call_vkDestroyDevice(struct vn_instance * vn_instance,VkDevice device,const VkAllocationCallbacks * pAllocator)21532 static inline void vn_call_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
21533 {
21534     VN_TRACE_FUNC();
21535 
21536     struct vn_instance_submit_command submit;
21537     vn_submit_vkDestroyDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit);
21538     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21539     if (dec) {
21540         vn_decode_vkDestroyDevice_reply(dec, device, pAllocator);
21541         vn_instance_free_command_reply(vn_instance, &submit);
21542     }
21543 }
21544 
vn_async_vkDestroyDevice(struct vn_instance * vn_instance,VkDevice device,const VkAllocationCallbacks * pAllocator)21545 static inline void vn_async_vkDestroyDevice(struct vn_instance *vn_instance, VkDevice device, const VkAllocationCallbacks* pAllocator)
21546 {
21547     struct vn_instance_submit_command submit;
21548     vn_submit_vkDestroyDevice(vn_instance, 0, device, pAllocator, &submit);
21549 }
21550 
vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)21551 static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
21552 {
21553     VN_TRACE_FUNC();
21554 
21555     struct vn_instance_submit_command submit;
21556     vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit);
21557     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21558     if (dec) {
21559         const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(dec, physicalDevice, pPropertyCount, pProperties);
21560         vn_instance_free_command_reply(vn_instance, &submit);
21561         return ret;
21562     } else {
21563         return VK_ERROR_OUT_OF_HOST_MEMORY;
21564     }
21565 }
21566 
vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)21567 static inline void vn_async_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
21568 {
21569     struct vn_instance_submit_command submit;
21570     vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, 0, physicalDevice, pPropertyCount, pProperties, &submit);
21571 }
21572 
vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)21573 static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
21574 {
21575     VN_TRACE_FUNC();
21576 
21577     struct vn_instance_submit_command submit;
21578     vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
21579     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21580     if (dec) {
21581         const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(dec, physicalDevice, pLayerName, pPropertyCount, pProperties);
21582         vn_instance_free_command_reply(vn_instance, &submit);
21583         return ret;
21584     } else {
21585         return VK_ERROR_OUT_OF_HOST_MEMORY;
21586     }
21587 }
21588 
vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)21589 static inline void vn_async_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
21590 {
21591     struct vn_instance_submit_command submit;
21592     vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, 0, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
21593 }
21594 
vn_call_vkGetDeviceQueue(struct vn_instance * vn_instance,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)21595 static inline void vn_call_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
21596 {
21597     VN_TRACE_FUNC();
21598 
21599     struct vn_instance_submit_command submit;
21600     vn_submit_vkGetDeviceQueue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit);
21601     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21602     if (dec) {
21603         vn_decode_vkGetDeviceQueue_reply(dec, device, queueFamilyIndex, queueIndex, pQueue);
21604         vn_instance_free_command_reply(vn_instance, &submit);
21605     }
21606 }
21607 
vn_async_vkGetDeviceQueue(struct vn_instance * vn_instance,VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)21608 static inline void vn_async_vkGetDeviceQueue(struct vn_instance *vn_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
21609 {
21610     struct vn_instance_submit_command submit;
21611     vn_submit_vkGetDeviceQueue(vn_instance, 0, device, queueFamilyIndex, queueIndex, pQueue, &submit);
21612 }
21613 
vn_call_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkDevice device)21614 static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
21615 {
21616     VN_TRACE_FUNC();
21617 
21618     struct vn_instance_submit_command submit;
21619     vn_submit_vkDeviceWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit);
21620     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21621     if (dec) {
21622         const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(dec, device);
21623         vn_instance_free_command_reply(vn_instance, &submit);
21624         return ret;
21625     } else {
21626         return VK_ERROR_OUT_OF_HOST_MEMORY;
21627     }
21628 }
21629 
vn_async_vkDeviceWaitIdle(struct vn_instance * vn_instance,VkDevice device)21630 static inline void vn_async_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkDevice device)
21631 {
21632     struct vn_instance_submit_command submit;
21633     vn_submit_vkDeviceWaitIdle(vn_instance, 0, device, &submit);
21634 }
21635 
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)21636 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)
21637 {
21638     VN_TRACE_FUNC();
21639 
21640     struct vn_instance_submit_command submit;
21641     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
21642     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21643     if (dec) {
21644         vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(dec, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
21645         vn_instance_free_command_reply(vn_instance, &submit);
21646     }
21647 }
21648 
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)21649 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)
21650 {
21651     struct vn_instance_submit_command submit;
21652     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, 0, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
21653 }
21654 
vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)21655 static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
21656 {
21657     VN_TRACE_FUNC();
21658 
21659     struct vn_instance_submit_command submit;
21660     vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
21661     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21662     if (dec) {
21663         vn_decode_vkGetPhysicalDeviceFeatures2_reply(dec, physicalDevice, pFeatures);
21664         vn_instance_free_command_reply(vn_instance, &submit);
21665     }
21666 }
21667 
vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures)21668 static inline void vn_async_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
21669 {
21670     struct vn_instance_submit_command submit;
21671     vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, 0, physicalDevice, pFeatures, &submit);
21672 }
21673 
vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)21674 static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
21675 {
21676     VN_TRACE_FUNC();
21677 
21678     struct vn_instance_submit_command submit;
21679     vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
21680     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21681     if (dec) {
21682         vn_decode_vkGetPhysicalDeviceProperties2_reply(dec, physicalDevice, pProperties);
21683         vn_instance_free_command_reply(vn_instance, &submit);
21684     }
21685 }
21686 
vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties)21687 static inline void vn_async_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
21688 {
21689     struct vn_instance_submit_command submit;
21690     vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, 0, physicalDevice, pProperties, &submit);
21691 }
21692 
vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)21693 static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
21694 {
21695     VN_TRACE_FUNC();
21696 
21697     struct vn_instance_submit_command submit;
21698     vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
21699     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21700     if (dec) {
21701         vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(dec, physicalDevice, format, pFormatProperties);
21702         vn_instance_free_command_reply(vn_instance, &submit);
21703     }
21704 }
21705 
vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties)21706 static inline void vn_async_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
21707 {
21708     struct vn_instance_submit_command submit;
21709     vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, 0, physicalDevice, format, pFormatProperties, &submit);
21710 }
21711 
vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)21712 static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
21713 {
21714     VN_TRACE_FUNC();
21715 
21716     struct vn_instance_submit_command submit;
21717     vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
21718     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21719     if (dec) {
21720         const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(dec, physicalDevice, pImageFormatInfo, pImageFormatProperties);
21721         vn_instance_free_command_reply(vn_instance, &submit);
21722         return ret;
21723     } else {
21724         return VK_ERROR_OUT_OF_HOST_MEMORY;
21725     }
21726 }
21727 
vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties)21728 static inline void vn_async_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
21729 {
21730     struct vn_instance_submit_command submit;
21731     vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, 0, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
21732 }
21733 
vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)21734 static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
21735 {
21736     VN_TRACE_FUNC();
21737 
21738     struct vn_instance_submit_command submit;
21739     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
21740     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21741     if (dec) {
21742         vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
21743         vn_instance_free_command_reply(vn_instance, &submit);
21744     }
21745 }
21746 
vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties)21747 static inline void vn_async_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
21748 {
21749     struct vn_instance_submit_command submit;
21750     vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, 0, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
21751 }
21752 
vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)21753 static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
21754 {
21755     VN_TRACE_FUNC();
21756 
21757     struct vn_instance_submit_command submit;
21758     vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
21759     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21760     if (dec) {
21761         vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(dec, physicalDevice, pMemoryProperties);
21762         vn_instance_free_command_reply(vn_instance, &submit);
21763     }
21764 }
21765 
vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties)21766 static inline void vn_async_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
21767 {
21768     struct vn_instance_submit_command submit;
21769     vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, 0, physicalDevice, pMemoryProperties, &submit);
21770 }
21771 
vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)21772 static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
21773 {
21774     VN_TRACE_FUNC();
21775 
21776     struct vn_instance_submit_command submit;
21777     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
21778     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21779     if (dec) {
21780         vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(dec, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
21781         vn_instance_free_command_reply(vn_instance, &submit);
21782     }
21783 }
21784 
vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties)21785 static inline void vn_async_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
21786 {
21787     struct vn_instance_submit_command submit;
21788     vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, 0, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
21789 }
21790 
vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)21791 static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
21792 {
21793     VN_TRACE_FUNC();
21794 
21795     struct vn_instance_submit_command submit;
21796     vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
21797     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21798     if (dec) {
21799         vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(dec, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
21800         vn_instance_free_command_reply(vn_instance, &submit);
21801     }
21802 }
21803 
vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties)21804 static inline void vn_async_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
21805 {
21806     struct vn_instance_submit_command submit;
21807     vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, 0, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
21808 }
21809 
vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)21810 static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
21811 {
21812     VN_TRACE_FUNC();
21813 
21814     struct vn_instance_submit_command submit;
21815     vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
21816     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21817     if (dec) {
21818         vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(dec, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
21819         vn_instance_free_command_reply(vn_instance, &submit);
21820     }
21821 }
21822 
vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties)21823 static inline void vn_async_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
21824 {
21825     struct vn_instance_submit_command submit;
21826     vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, 0, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
21827 }
21828 
vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)21829 static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
21830 {
21831     VN_TRACE_FUNC();
21832 
21833     struct vn_instance_submit_command submit;
21834     vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
21835     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21836     if (dec) {
21837         vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(dec, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
21838         vn_instance_free_command_reply(vn_instance, &submit);
21839     }
21840 }
21841 
vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties)21842 static inline void vn_async_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
21843 {
21844     struct vn_instance_submit_command submit;
21845     vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, 0, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
21846 }
21847 
vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)21848 static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
21849 {
21850     VN_TRACE_FUNC();
21851 
21852     struct vn_instance_submit_command submit;
21853     vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
21854     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21855     if (dec) {
21856         const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(dec, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
21857         vn_instance_free_command_reply(vn_instance, &submit);
21858         return ret;
21859     } else {
21860         return VK_ERROR_OUT_OF_HOST_MEMORY;
21861     }
21862 }
21863 
vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance * vn_instance,VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties)21864 static inline void vn_async_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
21865 {
21866     struct vn_instance_submit_command submit;
21867     vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, 0, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
21868 }
21869 
vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)21870 static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
21871 {
21872     VN_TRACE_FUNC();
21873 
21874     struct vn_instance_submit_command submit;
21875     vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
21876     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21877     if (dec) {
21878         vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(dec, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
21879         vn_instance_free_command_reply(vn_instance, &submit);
21880     }
21881 }
21882 
vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance * vn_instance,VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures)21883 static inline void vn_async_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
21884 {
21885     struct vn_instance_submit_command submit;
21886     vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, 0, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
21887 }
21888 
vn_call_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)21889 static inline void vn_call_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
21890 {
21891     VN_TRACE_FUNC();
21892 
21893     struct vn_instance_submit_command submit;
21894     vn_submit_vkGetDeviceQueue2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit);
21895     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21896     if (dec) {
21897         vn_decode_vkGetDeviceQueue2_reply(dec, device, pQueueInfo, pQueue);
21898         vn_instance_free_command_reply(vn_instance, &submit);
21899     }
21900 }
21901 
vn_async_vkGetDeviceQueue2(struct vn_instance * vn_instance,VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue)21902 static inline void vn_async_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
21903 {
21904     struct vn_instance_submit_command submit;
21905     vn_submit_vkGetDeviceQueue2(vn_instance, 0, device, pQueueInfo, pQueue, &submit);
21906 }
21907 
vn_call_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)21908 static inline VkResult vn_call_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
21909 {
21910     VN_TRACE_FUNC();
21911 
21912     struct vn_instance_submit_command submit;
21913     vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pTimeDomainCount, pTimeDomains, &submit);
21914     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21915     if (dec) {
21916         const VkResult ret = vn_decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_reply(dec, physicalDevice, pTimeDomainCount, pTimeDomains);
21917         vn_instance_free_command_reply(vn_instance, &submit);
21918         return ret;
21919     } else {
21920         return VK_ERROR_OUT_OF_HOST_MEMORY;
21921     }
21922 }
21923 
vn_async_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains)21924 static inline void vn_async_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
21925 {
21926     struct vn_instance_submit_command submit;
21927     vn_submit_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vn_instance, 0, physicalDevice, pTimeDomainCount, pTimeDomains, &submit);
21928 }
21929 
vn_call_vkGetCalibratedTimestampsEXT(struct vn_instance * vn_instance,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)21930 static inline VkResult vn_call_vkGetCalibratedTimestampsEXT(struct vn_instance *vn_instance, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
21931 {
21932     VN_TRACE_FUNC();
21933 
21934     struct vn_instance_submit_command submit;
21935     vn_submit_vkGetCalibratedTimestampsEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, &submit);
21936     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21937     if (dec) {
21938         const VkResult ret = vn_decode_vkGetCalibratedTimestampsEXT_reply(dec, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
21939         vn_instance_free_command_reply(vn_instance, &submit);
21940         return ret;
21941     } else {
21942         return VK_ERROR_OUT_OF_HOST_MEMORY;
21943     }
21944 }
21945 
vn_async_vkGetCalibratedTimestampsEXT(struct vn_instance * vn_instance,VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation)21946 static inline void vn_async_vkGetCalibratedTimestampsEXT(struct vn_instance *vn_instance, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
21947 {
21948     struct vn_instance_submit_command submit;
21949     vn_submit_vkGetCalibratedTimestampsEXT(vn_instance, 0, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, &submit);
21950 }
21951 
vn_call_vkGetPhysicalDeviceToolProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)21952 static inline VkResult vn_call_vkGetPhysicalDeviceToolProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
21953 {
21954     VN_TRACE_FUNC();
21955 
21956     struct vn_instance_submit_command submit;
21957     vn_submit_vkGetPhysicalDeviceToolProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pToolCount, pToolProperties, &submit);
21958     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
21959     if (dec) {
21960         const VkResult ret = vn_decode_vkGetPhysicalDeviceToolProperties_reply(dec, physicalDevice, pToolCount, pToolProperties);
21961         vn_instance_free_command_reply(vn_instance, &submit);
21962         return ret;
21963     } else {
21964         return VK_ERROR_OUT_OF_HOST_MEMORY;
21965     }
21966 }
21967 
vn_async_vkGetPhysicalDeviceToolProperties(struct vn_instance * vn_instance,VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties)21968 static inline void vn_async_vkGetPhysicalDeviceToolProperties(struct vn_instance *vn_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
21969 {
21970     struct vn_instance_submit_command submit;
21971     vn_submit_vkGetPhysicalDeviceToolProperties(vn_instance, 0, physicalDevice, pToolCount, pToolProperties, &submit);
21972 }
21973 
21974 #endif /* VN_PROTOCOL_DRIVER_DEVICE_H */
21975